Improvements of multicore support (from #139).

Functions now use cmake_parse_arguments for better consistency
with builtin cmake functions.

README.md

@@ -69,6 +69,10 @@ CMSIS creates following targets:
 
 So, if you don't need linker script, you can link only `CMSIS::STM32::<TYPE>` library and provide own script using `stm32_add_linker_script` function
 
+***Note**: Some devices in STM32H7 family has two different cores (Cortex-M7 and Cortex-M4). 
+To specify core to build, all targets for H7 family also have suffix (::M7 or ::M4).
+For example, targets for STM32H747BI will look like `CMSIS::STM32::H7::M7`, `CMSIS::STM32::H7::M4`, `CMSIS::STM32::H747BI::M7`, `CMSIS::STM32::H747BI::M4`, etc.*
+
 Also, there is special library `STM32::NoSys` which adds `--specs=nosys.specs` to compiler flags.
 
 ## HAL
@@ -87,6 +91,8 @@ HAL module will search all drivers supported by family and create following targ
 * `HAL::STM32::<FAMILY>::<DRIVER>Ex` (e.g. `HAL::STM32::F4::ADCEx`) - HAL Extension driver , depends on `HAL::STM32::<FAMILY>::<DRIVER>`
 * `HAL::STM32::<FAMILY>::LL_<DRIVER>` (e.g. `HAL::STM32::F4::LL_ADC`) - HAL LL (Low-Level) driver , depends on `HAL::STM32::<FAMILY>`
 
+***Note**: Targets for STM32H7 will look like `HAL::STM32::<FAMILY>::[M7|M4]`, `HAL::STM32::<FAMILY>::[M7|M4]::<DRIVER>`, etc.*
+
 Here is typical usage:
 
 ```
@@ -113,7 +119,7 @@ CMSIS package will generate linker script for your device automatically (target
 
 ## Useful cmake function
 
-* `stm32_get_chip_info(CHIP FAMILY TYPE DEVICE)` - classify device using name, will return device family, type and canonical name (uppercase without any package codes)
-* `stm32_get_memory_info(FAMILY DEVICE CORE FLASH_SIZE RAM_SIZE CCRAM_SIZE STACK_SIZE HEAP_SIZE FLASH_ORIGIN RAM_ORIGIN CCRAM_ORIGIN)` - get information about device memories. Linker script generator uses values from this function
-* `stm32_get_devices_by_family(FAMILY DEVICES)` - return into `DEVICES` all supported devices by family
+* `stm32_get_chip_info(<chip> [FAMILY <family>] [TYPE <type>] [DEVICE <device>])` - classify device using name, will return device family (into `<family>` variable), type (`<type>`) and canonical name (`<device>`, uppercase without any package codes)
+* `stm32_get_memory_info((CHIP <chip>)|(DEVICE <device> TYPE <type>) [FLASH|RAM|CCRAM|STACK|HEAP] [SIZE <size>] [ORIGIN <origin>])` - get information about device memories (into `<size>` and `<origin>`). Linker script generator uses values from this function
+* `stm32_get_devices_by_family(DEVICES [FAMILY <family>])` - return into `DEVICES` all supported devices by family (or all devices if `<family>` is empty)
 

cmake/FindBSP.cmake

@@ -222,21 +222,36 @@ if(NOT BSP_FIND_COMPONENTS)
     set(BSP_FIND_COMPONENTS 
         STM32F0 STM32F1 STM32F2 STM32F3 STM32F4 STM32F7
         STM32G0 STM32G4 
-        STM32H7
+        STM32H7_M7 STM32H7_M4
         STM32L0 STM32L1 STM32L4 
     )
 endif()
 
+if(STM32H7 IN_LIST BSP_FIND_COMPONENTS)
+    list(REMOVE_ITEM BSP_FIND_COMPONENTS STM32H7)
+    list(APPEND BSP_FIND_COMPONENTS STM32H7_M7 STM32H7_M4)
+endif()
+list(REMOVE_DUPLICATES BSP_FIND_COMPONENTS)
+
 foreach(COMP ${BSP_FIND_COMPONENTS})
     string(TOLOWER ${COMP} COMP_L)
     string(TOUPPER ${COMP} COMP_U)
     
-    string(REGEX MATCH "^STM32([FGHL][0-9]).*$" COMP_U ${COMP_U})
-    
+    string(REGEX MATCH "^STM32([A-Z][0-9])([0-9A-Z][0-9][A-Z][0-9A-Z])?_?(M[47])?.*$" COMP_U ${COMP_U})
     if(NOT CMAKE_MATCH_1)
-        message(FATAL_ERROR "Unknown BSP component: ${COMP}")
+        message(FATAL_ERROR "Unknown HAL component: ${COMP}")
     endif()
-        
+    
+    if(CMAKE_MATCH_3)
+        set(CORE ${CMAKE_MATCH_3})
+        set(CORE_C "::${CORE}")
+        set(CORE_U "_${CORE}")
+    else()
+        unset(CORE)
+        unset(CORE_C)
+        unset(CORE_U)
+    endif()
+
     set(FAMILY ${CMAKE_MATCH_1})
     string(TOLOWER ${FAMILY} FAMILY_L)
     
@@ -256,13 +271,19 @@ foreach(COMP ${BSP_FIND_COMPONENTS})
     
     set(BSP_${FAMILY}_INCLUDE "${BSP_${FAMILY}_PATH}/Components/Common")
     
-    add_library(BSP::STM32::${FAMILY} INTERFACE IMPORTED)
-    target_link_libraries(BSP::STM32::${FAMILY} INTERFACE STM32::${FAMILY})
-    target_include_directories(BSP::STM32::${FAMILY} INTERFACE "${BSP_${FAMILY}_PATH}/Components/Common")
+    add_library(BSP::STM32::${FAMILY}${CORE_C} INTERFACE IMPORTED)
+    target_link_libraries(BSP::STM32::${FAMILY}${CORE_C} INTERFACE STM32::${FAMILY}${CORE_C})
+    target_include_directories(BSP::STM32::${FAMILY}${CORE_C} INTERFACE "${BSP_${FAMILY}_PATH}/Components/Common")
         
     foreach(BOARD ${BSP_${FAMILY}_BOARDS})
         string(REPLACE "-" "_" BOARD_CANONICAL ${BOARD})
         string(TOLOWER ${BOARD_CANONICAL} BOARD_CANONICAL_L)
+        set(BOARD_DEVICE ${BSP_${FAMILY}_DEVICE_${BOARD_CANONICAL}})
+        
+        stm32_get_cores(DEV_CORES FAMILY ${FAMILY} DEVICE ${BOARD_DEVICE})
+        if(CORE AND (NOT ${CORE} IN_LIST DEV_CORES))
+            continue()
+        endif()
 
         find_path(BSP_${BOARD_CANONICAL}_PATH
             NAMES ${BOARD_CANONICAL_L}.h
@@ -273,16 +294,16 @@ foreach(COMP ${BSP_FIND_COMPONENTS})
             continue()
         endif()
         
-        add_library(BSP::STM32::${BOARD_CANONICAL} INTERFACE IMPORTED)
-        target_link_libraries(BSP::STM32::${BOARD_CANONICAL} INTERFACE BSP::STM32::${FAMILY} CMSIS::STM32::${FAMILY})
-        target_include_directories(BSP::STM32::${BOARD_CANONICAL} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}")
-        target_sources(BSP::STM32::${BOARD_CANONICAL} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}/${BOARD_CANONICAL_L}.c")
+        add_library(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE IMPORTED)
+        target_link_libraries(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE BSP::STM32::${FAMILY}${CORE_C} CMSIS::STM32::${FAMILY}${CORE_C})
+        target_include_directories(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}")
+        target_sources(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}/${BOARD_CANONICAL_L}.c")
         
         foreach(SRC ${BSP_${FAMILY}_SOURCES_${BOARD_CANONICAL}})
-            target_sources(BSP::STM32::${BOARD_CANONICAL} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}/${BOARD_CANONICAL_L}_${SRC}.c")
+            target_sources(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE "${BSP_${BOARD_CANONICAL}_PATH}/${BOARD_CANONICAL_L}_${SRC}.c")
         endforeach()
         if(BSP_${FAMILY}_DEVICE_${BOARD_CANONICAL})
-            target_link_libraries(BSP::STM32::${BOARD_CANONICAL} INTERFACE CMSIS::STM32::${BSP_${FAMILY}_DEVICE_${BOARD_CANONICAL}})
+            target_link_libraries(BSP::STM32::${BOARD_CANONICAL}${CORE_C} INTERFACE CMSIS::STM32::${BSP_${FAMILY}_DEVICE_${BOARD_CANONICAL}}${CORE_C})
         endif()
     endforeach()
     
@@ -290,9 +311,9 @@ foreach(COMP ${BSP_FIND_COMPONENTS})
         string(TOLOWER ${BCOMP} BCOMP_L)
         string(TOUPPER ${BCOMP} BCOMP_U)
         
-        add_library(BSP::STM32::${FAMILY}::${BCOMP_U} INTERFACE IMPORTED)
-        target_link_libraries(BSP::STM32::${FAMILY}::${BCOMP_U} INTERFACE BSP::STM32::${FAMILY} CMSIS::STM32::${FAMILY})
-        target_include_directories(BSP::STM32::${FAMILY}::${BCOMP_U} INTERFACE "${BSP_${FAMILY}_PATH}/Components/${BCOMP}")
+        add_library(BSP::STM32::${FAMILY}${CORE_C}::${BCOMP_U} INTERFACE IMPORTED)
+        target_link_libraries(BSP::STM32::${FAMILY}${CORE_C}::${BCOMP_U} INTERFACE BSP::STM32::${FAMILY}${CORE_C} CMSIS::STM32::${FAMILY}${CORE_C})
+        target_include_directories(BSP::STM32::${FAMILY}${CORE_C}::${BCOMP_U} INTERFACE "${BSP_${FAMILY}_PATH}/Components/${BCOMP}")
         
         find_file(BSP_${BOARD_CANONICAL}_${COMP}_SOURCE
             NAMES ${BCOMP}.c
@@ -300,7 +321,7 @@ foreach(COMP ${BSP_FIND_COMPONENTS})
             NO_DEFAULT_PATH
         )
         if (BSP_${BOARD_CANONICAL}_${COMP}_SOURCE)
-            target_sources(BSP::STM32::${FAMILY}::${BCOMP_U} INTERFACE "${BSP_${BOARD_CANONICAL}_${COMP}_SOURCE}")
+            target_sources(BSP::STM32::${FAMILY}${CORE_C}::${BCOMP_U} INTERFACE "${BSP_${BOARD_CANONICAL}_${COMP}_SOURCE}")
         endif()
     endforeach()
     

cmake/FindCMSIS.cmake

@@ -2,20 +2,34 @@ if(NOT CMSIS_FIND_COMPONENTS)
     set(CMSIS_FIND_COMPONENTS
         STM32F0 STM32F1 STM32F2 STM32F3 STM32F4 STM32F7
         STM32G0 STM32G4
-        STM32H7
+        STM32H7_M7 STM32H7_M4
         STM32L0 STM32L1 STM32L4
     )
 endif()
 
+if(STM32H7 IN_LIST CMSIS_FIND_COMPONENTS)
+    list(REMOVE_ITEM CMSIS_FIND_COMPONENTS STM32H7)
+    list(APPEND CMSIS_FIND_COMPONENTS STM32H7_M7 STM32H7_M4)
+endif()
+list(REMOVE_DUPLICATES CMSIS_FIND_COMPONENTS)
+
 include(stm32/devices)
-    
+
 function(cmsis_generate_default_linker_script FAMILY DEVICE CORE)
-    string(REPLACE "_" "::" CORE_C ${CORE})
-    stm32_get_memory_info(${FAMILY} ${DEVICE} ${CORE}
-        FLASH_SIZE RAM_SIZE CCRAM_SIZE STACK_SIZE HEAP_SIZE 
-        FLASH_ORIGIN RAM_ORIGIN CCRAM_ORIGIN
-    )
-    add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld"
+    if(CORE)
+        set(CORE_C "::${CORE}")
+        set(CORE_U "_${CORE}")
+    endif()
+    
+    set(OUTPUT_LD_FILE "${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE_U}.ld")
+    
+    stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} FLASH SIZE FLASH_SIZE ORIGIN FLASH_ORIGIN)
+    stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} RAM SIZE RAM_SIZE ORIGIN RAM_ORIGIN)
+    stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} CCRAM SIZE CCRAM_SIZE ORIGIN CCRAM_ORIGIN)
+    stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} HEAP SIZE HEAP_SIZE)
+    stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} STACK SIZE STACK_SIZE)
+    
+    add_custom_command(OUTPUT "${OUTPUT_LD_FILE}"
         COMMAND ${CMAKE_COMMAND} 
             -DFLASH_ORIGIN="${FLASH_ORIGIN}" 
             -DRAM_ORIGIN="${RAM_ORIGIN}" 
@@ -25,19 +39,19 @@ function(cmsis_generate_default_linker_script FAMILY DEVICE CORE)
             -DCCRAM_SIZE="${CCRAM_SIZE}" 
             -DSTACK_SIZE="${STACK_SIZE}" 
             -DHEAP_SIZE="${HEAP_SIZE}" 
-            -DLINKER_SCRIPT="${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld"
+            -DLINKER_SCRIPT="${OUTPUT_LD_FILE}"
             -P "${STM32_CMAKE_DIR}/stm32/linker_ld.cmake"
     )
-    add_custom_target(CMSIS_LD_${DEVICE}${CORE} DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld)
-    add_dependencies(CMSIS::STM32::${DEVICE}${CORE_C} CMSIS_LD_${DEVICE}${CORE})
-    stm32_add_linker_script(CMSIS::STM32::${DEVICE}${CORE_C} INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld")
+    add_custom_target(CMSIS_LD_${DEVICE}${CORE_U} DEPENDS "${OUTPUT_LD_FILE}")
+    add_dependencies(CMSIS::STM32::${DEVICE}${CORE_C} CMSIS_LD_${DEVICE}${CORE_U})
+    stm32_add_linker_script(CMSIS::STM32::${DEVICE}${CORE_C} INTERFACE "${OUTPUT_LD_FILE}")
 endfunction() 
 
 foreach(COMP ${CMSIS_FIND_COMPONENTS})
     string(TOLOWER ${COMP} COMP_L)
     string(TOUPPER ${COMP} COMP)
     
-    string(REGEX MATCH "^STM32([A-Z][0-9])([0-9A-Z][0-9][A-Z][0-9A-Z])?(_M[47])?.*$" COMP ${COMP})
+    string(REGEX MATCH "^STM32([A-Z][0-9])([0-9A-Z][0-9][A-Z][0-9A-Z])?_?(M[47])?.*$" COMP ${COMP})
     
     if((NOT CMAKE_MATCH_1) AND (NOT CMAKE_MATCH_2))
         message(FATAL_ERROR "Unknown CMSIS component: ${COMP}")
@@ -48,12 +62,19 @@ foreach(COMP ${CMSIS_FIND_COMPONENTS})
         set(DEVICES "${CMAKE_MATCH_1}${CMAKE_MATCH_2}")
     else()
         set(FAMILY ${CMAKE_MATCH_1})
-        stm32_get_devices_by_family(${FAMILY} DEVICES)
+        stm32_get_devices_by_family(DEVICES FAMILY ${FAMILY} CORE ${CORE})
     endif()
+    
     if(CMAKE_MATCH_3)
         set(CORE ${CMAKE_MATCH_3})
-        string(REGEX REPLACE "_" "::" CORE_C ${CORE})
+        set(CORE_C "::${CORE}")
+        set(CORE_U "_${CORE}")
+    else()
+        unset(CORE)
+        unset(CORE_C)
+        unset(CORE_U)
     endif()
+    
     string(TOLOWER ${FAMILY} FAMILY_L)
     
     if(NOT STM32_CUBE_${FAMILY}_PATH)
@@ -61,100 +82,105 @@ foreach(COMP ${CMSIS_FIND_COMPONENTS})
         message(STATUS "No STM32_CUBE_${FAMILY}_PATH specified using default: ${STM32_CUBE_${FAMILY}_PATH}")
     endif()
         
-    find_path(CMSIS_${FAMILY}${CORE}_PATH
+    find_path(CMSIS_${FAMILY}${CORE_U}_PATH
         NAMES Include/cmsis_gcc.h
         PATHS "${STM32_CUBE_${FAMILY}_PATH}/Drivers/CMSIS"
         NO_DEFAULT_PATH
     )
-    if (NOT CMSIS_${FAMILY}${CORE}_PATH)
+    if (NOT CMSIS_${FAMILY}${CORE_U}_PATH)
         continue()
     endif()
     
-    if(NOT CMSIS_${FAMILY}${CORE}_VERSION)
-        find_file(CMSIS_${FAMILY}${CORE}_PDSC
+    if(NOT CMSIS_${FAMILY}${CORE_U}_VERSION)
+        find_file(CMSIS_${FAMILY}${CORE_U}_PDSC
             NAMES ARM.CMSIS.pdsc
-            PATHS "${CMSIS_${FAMILY}${CORE}_PATH}"
+            PATHS "${CMSIS_${FAMILY}${CORE_U}_PATH}"
             NO_DEFAULT_PATH
         )
-        if (NOT CMSIS_${FAMILY}${CORE}_PDSC)
-            set(CMSIS_${FAMILY}${CORE}_VERSION "0.0.0")
+        if (NOT CMSIS_${FAMILY}${CORE_U}_PDSC)
+            set(CMSIS_${FAMILY}${CORE_U}_VERSION "0.0.0")
         else()
-            file(STRINGS "${CMSIS_${FAMILY}${CORE}_PDSC}" VERSION_STRINGS REGEX "<release version=\"([0-9]*\\.[0-9]*\\.[0-9]*)\" date=\"[0-9]+\\-[0-9]+\\-[0-9]+\">")
+            file(STRINGS "${CMSIS_${FAMILY}${CORE_U}_PDSC}" VERSION_STRINGS REGEX "<release version=\"([0-9]*\\.[0-9]*\\.[0-9]*)\" date=\"[0-9]+\\-[0-9]+\\-[0-9]+\">")
             list(GET VERSION_STRINGS 0 STR)
             string(REGEX MATCH "<release version=\"([0-9]*)\\.([0-9]*)\\.([0-9]*)\" date=\"[0-9]+\\-[0-9]+\\-[0-9]+\">" MATCHED ${STR})
-            set(CMSIS_${FAMILY}${CORE}_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" CACHE INTERNAL "CMSIS STM32${FAMILY}${CORE} version")
+            set(CMSIS_${FAMILY}${CORE_U}_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" CACHE INTERNAL "CMSIS STM32${FAMILY}${CORE_U} version")
         endif()
     endif()
     
-    set(CMSIS_${COMP}_VERSION ${CMSIS_${FAMILY}${CORE}_VERSION})
+    set(CMSIS_${COMP}_VERSION ${CMSIS_${FAMILY}${CORE_U}_VERSION})
     set(CMSIS_VERSION ${CMSIS_${COMP}_VERSION})
     
-    find_path(CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE
+    find_path(CMSIS_${FAMILY}${CORE_U}_COMMON_INCLUDE
         NAMES cmsis_gcc.h
-        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Include"
+        PATHS "${CMSIS_${FAMILY}${CORE_U}_PATH}/Include"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE}")
+    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE_U}_COMMON_INCLUDE}")
     
-    find_path(CMSIS_${FAMILY}${CORE}_INCLUDE
+    find_path(CMSIS_${FAMILY}${CORE_U}_INCLUDE
         NAMES stm32${FAMILY_L}xx.h
-        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Include"
+        PATHS "${CMSIS_${FAMILY}${CORE_U}_PATH}/Device/ST/STM32${FAMILY}xx/Include"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE}_INCLUDE}")
+    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE_U}_INCLUDE}")
     
-    find_file(CMSIS_${FAMILY}${CORE}_SOURCE
+    find_file(CMSIS_${FAMILY}${CORE_U}_SOURCE
         NAMES system_stm32${FAMILY_L}xx.c
-        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates"
+        PATHS "${CMSIS_${FAMILY}${CORE_U}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE}_SOURCE}")
+    list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE_U}_SOURCE}")
     
-    if ((NOT CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE) OR 
-        (NOT CMSIS_${FAMILY}${CORE}_INCLUDE) OR 
-        (NOT CMSIS_${FAMILY}${CORE}_SOURCE))
+    if ((NOT CMSIS_${FAMILY}${CORE_U}_COMMON_INCLUDE) OR 
+        (NOT CMSIS_${FAMILY}${CORE_U}_INCLUDE) OR 
+        (NOT CMSIS_${FAMILY}${CORE_U}_SOURCE))
         continue()
     endif()
 
     if(NOT (TARGET CMSIS::STM32::${FAMILY}${CORE_C}))
         add_library(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE IMPORTED)
         target_link_libraries(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE STM32::${FAMILY}${CORE_C})
-        target_include_directories(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE}")
-        target_include_directories(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE}_INCLUDE}")
-        target_sources(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE}_SOURCE}")
+        target_include_directories(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE_U}_COMMON_INCLUDE}")
+        target_include_directories(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE_U}_INCLUDE}")
+        target_sources(CMSIS::STM32::${FAMILY}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE_U}_SOURCE}")
     endif()
 
     set(DEVICES_FOUND TRUE)
     foreach(DEVICE ${DEVICES})
+        stm32_get_cores(DEV_CORES FAMILY ${FAMILY} DEVICE ${DEVICE})
+        if(CORE AND (NOT ${CORE} IN_LIST DEV_CORES))
+            continue()
+        endif()
+                
         stm32_get_chip_type(${FAMILY} ${DEVICE} TYPE)
         string(TOLOWER ${DEVICE} DEVICE_L)
         string(TOLOWER ${TYPE} TYPE_L)
         
-        find_file(CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP
+        find_file(CMSIS_${FAMILY}${CORE_U}_${TYPE}_STARTUP
             NAMES startup_stm32${TYPE_L}.s
-            PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates/gcc"
+            PATHS "${CMSIS_${FAMILY}${CORE_U}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates/gcc"
             NO_DEFAULT_PATH
         )
-        list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP}")
-        if(NOT CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP)
+        list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE_U}_${TYPE}_STARTUP}")
+        if(NOT CMSIS_${FAMILY}${CORE_U}_${TYPE}_STARTUP)
             set(DEVICES_FOUND FALSE)
             break()
         endif()
         
-        if(NOT (TARGET CMSIS::STM32::${TYPE}${CORE}))
+        if(NOT (TARGET CMSIS::STM32::${TYPE}${CORE_C}))
             add_library(CMSIS::STM32::${TYPE}${CORE_C} INTERFACE IMPORTED)
             target_link_libraries(CMSIS::STM32::${TYPE}${CORE_C} INTERFACE CMSIS::STM32::${FAMILY}${CORE_C} STM32::${TYPE}${CORE_C})
-            target_sources(CMSIS::STM32::${TYPE}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP}")
+            target_sources(CMSIS::STM32::${TYPE}${CORE_C} INTERFACE "${CMSIS_${FAMILY}${CORE_U}_${TYPE}_STARTUP}")
         endif()
         
         add_library(CMSIS::STM32::${DEVICE}${CORE_C} INTERFACE IMPORTED)
         target_link_libraries(CMSIS::STM32::${DEVICE}${CORE_C} INTERFACE CMSIS::STM32::${TYPE}${CORE_C})
-        cmsis_generate_default_linker_script(${FAMILY} ${DEVICE} ${CORE})
+        cmsis_generate_default_linker_script(${FAMILY} ${DEVICE} "${CORE}")
     endforeach()
-        
-    if(CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE AND 
-       CMSIS_${FAMILY}${CORE}_INCLUDE AND 
-       CMSIS_${FAMILY}${CORE}_SOURCE AND
+
+    if(CMSIS_${FAMILY}${CORE_U}_COMMON_INCLUDE AND 
+       CMSIS_${FAMILY}${CORE_U}_INCLUDE AND 
+       CMSIS_${FAMILY}${CORE_U}_SOURCE AND
        DEVICES_FOUND)
        set(CMSIS_${COMP}_FOUND TRUE)
     else()

cmake/FindHAL.cmake

@@ -161,24 +161,34 @@ if(NOT HAL_FIND_COMPONENTS)
     set(HAL_FIND_COMPONENTS
         STM32F0 STM32F1 STM32F2 STM32F3 STM32F4 STM32F7
         STM32G0 STM32G4
-        STM32H7
+        STM32H7_M7 STM32H7_M4
         STM32L0 STM32L1 STM32L4
     )
 endif()
 
+if(STM32H7 IN_LIST HAL_FIND_COMPONENTS)
+    list(REMOVE_ITEM HAL_FIND_COMPONENTS STM32H7)
+    list(APPEND HAL_FIND_COMPONENTS STM32H7_M7 STM32H7_M4)
+endif()
+list(REMOVE_DUPLICATES HAL_FIND_COMPONENTS)
+
 foreach(COMP ${HAL_FIND_COMPONENTS})
     string(TOLOWER ${COMP} COMP_L)
     string(TOUPPER ${COMP} COMP_U)
     
-    string(REGEX MATCH "_M[47]$" CORE ${COMP_U})
-    string(REGEX MATCH "^STM32([FGHL][0-9]).*$" COMP_U ${COMP_U})
-    
+    string(REGEX MATCH "^STM32([A-Z][0-9])([0-9A-Z][0-9][A-Z][0-9A-Z])?_?(M[47])?.*$" COMP_U ${COMP_U})
     if(NOT CMAKE_MATCH_1)
         message(FATAL_ERROR "Unknown HAL component: ${COMP}")
     endif()
-
-    if(CORE)
-        string(REPLACE "_" "::" CORE_C "${CORE}")
+    
+    if(CMAKE_MATCH_3)
+        set(CORE ${CMAKE_MATCH_3})
+        set(CORE_C "::${CORE}")
+        set(CORE_U "_${CORE}")
+    else()
+        unset(CORE)
+        unset(CORE_C)
+        unset(CORE_U)
     endif()
         
     set(FAMILY ${CMAKE_MATCH_1})
@@ -198,18 +208,18 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
         continue()
     endif()
     
-    find_path(HAL_${FAMILY}${CORE}_INCLUDE
+    find_path(HAL_${FAMILY}${CORE_U}_INCLUDE
         NAMES stm32${FAMILY_L}xx_hal.h
         PATHS "${HAL_${FAMILY}_PATH}/Inc"
         NO_DEFAULT_PATH
     )
-    find_file(HAL_${FAMILY}${CORE}_SOURCE
+    find_file(HAL_${FAMILY}${CORE_U}_SOURCE
         NAMES stm32${FAMILY_L}xx_hal.c
         PATHS "${HAL_${FAMILY}_PATH}/Src"
         NO_DEFAULT_PATH
     )
     
-    if ((NOT HAL_${FAMILY}${CORE}_INCLUDE) OR (NOT HAL_${FAMILY}${CORE}_SOURCE))
+    if ((NOT HAL_${FAMILY}${CORE_U}_INCLUDE) OR (NOT HAL_${FAMILY}${CORE_U}_SOURCE))
         set(HAL_${COMP}_FOUND FALSE)
         continue()
     endif()
@@ -217,45 +227,45 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
     if(NOT (TARGET HAL::STM32::${FAMILY}${CORE_C}))
         add_library(HAL::STM32::${FAMILY}${CORE_C} INTERFACE IMPORTED)
         target_link_libraries(HAL::STM32::${FAMILY}${CORE_C} INTERFACE STM32::${FAMILY}${CORE_C} CMSIS::STM32::${FAMILY}${CORE_C})
-        target_include_directories(HAL::STM32::${FAMILY}${CORE_C} INTERFACE "${HAL_${FAMILY}${CORE}_INCLUDE}")
-        target_sources(HAL::STM32::${FAMILY}${CORE_C} INTERFACE "${HAL_${FAMILY}${CORE}_SOURCE}")
+        target_include_directories(HAL::STM32::${FAMILY}${CORE_C} INTERFACE "${HAL_${FAMILY}${CORE_U}_INCLUDE}")
+        target_sources(HAL::STM32::${FAMILY}${CORE_C} INTERFACE "${HAL_${FAMILY}${CORE_U}_SOURCE}")
     endif()
     
     foreach(DRV ${HAL_DRIVERS_${FAMILY}})
         string(TOLOWER ${DRV} DRV_L)
         string(TOUPPER ${DRV} DRV)
         
-        find_file(HAL_${FAMILY}${CORE}_${DRV}_SOURCE
+        find_file(HAL_${FAMILY}${CORE_U}_${DRV}_SOURCE
             NAMES stm32${FAMILY_L}xx_hal_${DRV_L}.c
             PATHS "${HAL_${FAMILY}_PATH}/Src"
             NO_DEFAULT_PATH
         )
-        list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}_${DRV}_SOURCE}")
-        if(NOT HAL_${FAMILY}${CORE}_${DRV}_SOURCE)
+        list(APPEND HAL_${FAMILY}${CORE_U}_SOURCES "${HAL_${FAMILY}_${DRV}_SOURCE}")
+        if(NOT HAL_${FAMILY}${CORE_U}_${DRV}_SOURCE)
             message(WARNING "Cannot find ${DRV} driver for ${COMP}")
         endif()
                 
-        if(HAL_${FAMILY}${CORE}_${DRV}_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}::${DRV})))
+        if(HAL_${FAMILY}${CORE_U}_${DRV}_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}::${DRV})))
             add_library(HAL::STM32::${FAMILY}${CORE_C}::${DRV} INTERFACE IMPORTED)
             target_link_libraries(HAL::STM32::${FAMILY}${CORE_C}::${DRV} INTERFACE HAL::STM32::${FAMILY}${CORE_C})
-            target_sources(HAL::STM32::${FAMILY}${CORE_C}::${DRV} INTERFACE "${HAL_${FAMILY}${CORE}_${DRV}_SOURCE}")
+            target_sources(HAL::STM32::${FAMILY}${CORE_C}::${DRV} INTERFACE "${HAL_${FAMILY}${CORE_U}_${DRV}_SOURCE}")
         endif()
                 
-        if(HAL_${FAMILY}${CORE}_${DRV}_SOURCE AND (${DRV_L} IN_LIST HAL_EX_DRIVERS_${FAMILY}))
-            find_file(HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE
+        if(HAL_${FAMILY}${CORE_U}_${DRV}_SOURCE AND (${DRV_L} IN_LIST HAL_EX_DRIVERS_${FAMILY}))
+            find_file(HAL_${FAMILY}${CORE_U}_${DRV}_EX_SOURCE
                 NAMES stm32${FAMILY_L}xx_hal_${DRV_L}_ex.c
                 PATHS "${HAL_${FAMILY}_PATH}/Src"
                 NO_DEFAULT_PATH
             )
-            list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE}")
-            if(NOT HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE)
+            list(APPEND HAL_${FAMILY}${CORE_U}_SOURCES "${HAL_${FAMILY}${CORE_U}_${DRV}_EX_SOURCE}")
+            if(NOT HAL_${FAMILY}${CORE_U}_${DRV}_EX_SOURCE)
                 message(WARNING "Cannot find ${DRV}Ex driver for ${COMP}")
             endif()
-            
+                        
             if((TARGET HAL::STM32::${FAMILY}${CORE_C}::${DRV}) AND (NOT (TARGET HAL::STM32::${FAMILY}${CORE_C}::${DRV}Ex)))
                 add_library(HAL::STM32::${FAMILY}${CORE_C}::${DRV}Ex INTERFACE IMPORTED)
                 target_link_libraries(HAL::STM32::${FAMILY}${CORE_C}::${DRV}Ex INTERFACE HAL::STM32::${FAMILY}${CORE_C}::${DRV})
-                target_sources(HAL::STM32::${FAMILY}${CORE_C}::${DRV}Ex INTERFACE "${HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE}")
+                target_sources(HAL::STM32::${FAMILY}${CORE_C}::${DRV}Ex INTERFACE "${HAL_${FAMILY}${CORE_U}_${DRV}_EX_SOURCE}")
             endif()
         endif()
     endforeach()
@@ -264,25 +274,25 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
         string(TOLOWER ${DRV} DRV_L)
         string(TOUPPER ${DRV} DRV)
         
-        find_file(HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE
+        find_file(HAL_${FAMILY}${CORE_U}_${DRV}_LL_SOURCE
             NAMES stm32${FAMILY_L}xx_ll_${DRV_L}.c
             PATHS "${HAL_${FAMILY}_PATH}/Src"
             NO_DEFAULT_PATH
         )
-        list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}_${DRV}_LL_SOURCE}")
-        if(NOT HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE)
+        list(APPEND HAL_${FAMILY}${CORE_U}_SOURCES "${HAL_${FAMILY}_${DRV}_LL_SOURCE}")
+        if(NOT HAL_${FAMILY}${CORE_U}_${DRV}_LL_SOURCE)
             message(WARNING "Cannot find LL_${DRV} driver for ${COMP}")
         endif()
     
-        if(HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV})))
+        if(HAL_${FAMILY}${CORE_U}_${DRV}_LL_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV})))
             add_library(HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV} INTERFACE IMPORTED)
-            target_link_libraries(HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV} INTERFACE HAL::STM32::${FAMILY})
-            target_sources(HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV} INTERFACE "${HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE}")
+            target_link_libraries(HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV} INTERFACE HAL::STM32::${FAMILY}${CORE_C})
+            target_sources(HAL::STM32::${FAMILY}${CORE_C}::LL_${DRV} INTERFACE "${HAL_${FAMILY}${CORE_U}_${DRV}_LL_SOURCE}")
         endif()
     endforeach()
     
     set(HAL_${COMP}_FOUND TRUE)
-    foreach(FILE ${HAL_${FAMILY}${CORE}_SOURCES})
+    foreach(FILE ${HAL_${FAMILY}${CORE_U}_SOURCES})
         if(NOT FILE)
             set(HAL_${COMP}_FOUND FALSE)
             break()
@@ -290,8 +300,8 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
     endforeach()
         
     if(HAL_${COMP}_FOUND)
-        list(APPEND HAL_INCLUDE_DIRS "${HAL_${FAMILY}${CORE}_INCLUDE}")
-        list(APPEND HAL_SOURCES "${HAL_${FAMILY}${CORE}_SOURCES}")
+        list(APPEND HAL_INCLUDE_DIRS "${HAL_${FAMILY}${CORE_U}_INCLUDE}")
+        list(APPEND HAL_SOURCES "${HAL_${FAMILY}${CORE_U}_SOURCES}")
     endif()
     list(REMOVE_DUPLICATES HAL_INCLUDE_DIRS)
     list(REMOVE_DUPLICATES HAL_SOURCES)

cmake/stm32/common.cmake

@@ -41,7 +41,12 @@ function(stm32_get_chip_type FAMILY DEVICE TYPE)
     set(${TYPE} ${RESULT_TYPE} PARENT_SCOPE)
 endfunction()
 
-function(stm32_get_chip_info CHIP FAMILY TYPE DEVICE)
+function(stm32_get_chip_info CHIP)
+    set(ARG_OPTIONS "")
+    set(ARG_SINGLE FAMILY DEVICE TYPE)
+    set(ARG_MULTIPLE "")
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "${ARG_OPTIONS}" "${ARG_SINGLE}" "${ARG_MULTIPLE}")
+        
     string(TOUPPER ${CHIP} CHIP)
         
     string(REGEX MATCH "^STM32([A-Z][0-9])([0-9A-Z][0-9][A-Z][0-9A-Z]).*$" CHIP ${CHIP})
@@ -60,16 +65,61 @@ function(stm32_get_chip_info CHIP FAMILY TYPE DEVICE)
 
     stm32_get_chip_type(${STM32_FAMILY} ${STM32_DEVICE} STM32_TYPE)
     
-    set(${FAMILY} ${STM32_FAMILY} PARENT_SCOPE)
-    set(${DEVICE} ${STM32_DEVICE} PARENT_SCOPE)
-    set(${TYPE} ${STM32_TYPE} PARENT_SCOPE)
+    if(ARG_FAMILY)
+        set(${ARG_FAMILY} ${STM32_FAMILY} PARENT_SCOPE)
+    endif()
+    if(ARG_DEVICE)
+        set(${ARG_DEVICE} ${STM32_DEVICE} PARENT_SCOPE)
+    endif()
+    if(ARG_TYPE)
+        set(${ARG_TYPE} ${STM32_TYPE} PARENT_SCOPE)
+    endif()
 endfunction()
 
-function(stm32_get_memory_info FAMILY DEVICE CORE
-    FLASH_SIZE RAM_SIZE CCRAM_SIZE STACK_SIZE HEAP_SIZE 
-    FLASH_ORIGIN RAM_ORIGIN CCRAM_ORIGIN
-)
-    string(REGEX REPLACE "^[FGHL][0-9][0-9A-Z][0-9].([3468BCDEFGHIZ])$" "\\1" SIZE_CODE ${DEVICE})
+function(stm32_get_cores CORES)
+    set(ARG_OPTIONS "")
+    set(ARG_SINGLE CHIP FAMILY DEVICE)
+    set(ARG_MULTIPLE "")
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "${ARG_OPTIONS}" "${ARG_SINGLE}" "${ARG_MULTIPLE}")
+        
+    if(ARG_CHIP)
+        stm32_get_chip_info(${ARG_CHIP} FAMILY ARG_FAMILY TYPE ARG_TYPE DEVICE ARG_DEVICE)
+    elseif(ARG_FAMILY AND ARG_DEVICE)
+        stm32_get_chip_type(${ARG_FAMILY} ${ARG_DEVICE} ARG_TYPE)
+    elseif(ARG_FAMILY)
+        if(${ARG_FAMILY} STREQUAL "H7")
+            set(${CORES} M7 M4 PARENT_SCOPE)
+        else()
+            set(${CORES} "" PARENT_SCOPE)
+        endif()
+        return()
+    else()
+        message(FATAL_ERROR "Either CHIP or FAMILY or FAMILY/DEVICE should be specified for stm32_get_cores()")
+    endif()
+    
+    if(${ARG_FAMILY} STREQUAL "H7")
+        stm32h7_get_device_cores(${ARG_DEVICE} ${ARG_TYPE} CORE_LIST)
+    endif()
+    set(${CORES} "${CORE_LIST}" PARENT_SCOPE)
+endfunction()
+
+function(stm32_get_memory_info)
+    set(ARG_OPTIONS FLASH RAM CCRAM STACK HEAP)
+    set(ARG_SINGLE CHIP FAMILY DEVICE CORE SIZE ORIGIN)
+    set(ARG_MULTIPLE "")
+    cmake_parse_arguments(INFO "${ARG_OPTIONS}" "${ARG_SINGLE}" "${ARG_MULTIPLE}" ${ARGN})
+
+    if((NOT INFO_CHIP) AND ((NOT INFO_FAMILY) OR (NOT INFO_DEVICE)))
+        message(FATAL_ERROR "Either CHIP or FAMILY/DEVICE is required for stm32_get_memory_info()")
+    endif()
+        
+    if(INFO_CHIP)
+        stm32_get_chip_info(${INFO_CHIP} FAMILY INFO_FAMILY TYPE INFO_TYPE DEVICE INFO_DEVICE)
+    else()
+        stm32_get_chip_type(${INFO_FAMILY} ${INFO_DEVICE} INFO_TYPE)
+    endif()
+    
+    string(REGEX REPLACE "^[FGHL][0-9][0-9A-Z][0-9].([3468BCDEFGHIZ])$" "\\1" SIZE_CODE ${INFO_DEVICE})
     
     if(SIZE_CODE STREQUAL "3")
         set(FLASH "8K")
@@ -102,41 +152,61 @@ function(stm32_get_memory_info FAMILY DEVICE CORE
         message(WARNING "Unknow flash size for device ${DEVICE}. Set to ${FLASH}")
     endif()
     
-    stm32_get_chip_type(${FAMILY} ${DEVICE} TYPE)
-    list(FIND STM32_${FAMILY}_TYPES ${TYPE} TYPE_INDEX)
-    list(GET STM32_${FAMILY}_RAM_SIZES ${TYPE_INDEX} RAM)
-    list(GET STM32_${FAMILY}_CCRAM_SIZES ${TYPE_INDEX} CCRAM)
-    set(FLASH_ORIGIN_VALUE 0x8000000)
-    set(RAM_ORIGIN_VALUE 0x20000000 PARENT_SCOPE)
-    set(CCRAM_ORIGIN_VALUE 0x10000000 PARENT_SCOPE)
+    list(FIND STM32_${INFO_FAMILY}_TYPES ${INFO_TYPE} TYPE_INDEX)
+    list(GET STM32_${INFO_FAMILY}_RAM_SIZES ${TYPE_INDEX} RAM)
+    list(GET STM32_${INFO_FAMILY}_CCRAM_SIZES ${TYPE_INDEX} CCRAM)
+    set(FLASH_ORIGIN 0x8000000)
+    set(RAM_ORIGIN 0x20000000)
+    set(CCRAM_ORIGIN 0x10000000)
     
     if(FAMILY STREQUAL "F1")
-        stm32f1_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
+        stm32f1_get_memory_info(${INFO_DEVICE} ${INFO_TYPE} FLASH RAM)
     elseif(FAMILY STREQUAL "L1")
-        stm32l1_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
+        stm32l1_get_memory_info(${INFO_DEVICE} ${INFO_TYPE} FLASH RAM)
     elseif(FAMILY STREQUAL "F2")
-        stm32f2_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
+        stm32f2_get_memory_info(${INFO_DEVICE} ${INFO_TYPE} FLASH RAM)
     elseif(FAMILY STREQUAL "F3")
-        stm32f3_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
+        stm32f3_get_memory_info(${INFO_DEVICE} ${INFO_TYPE} FLASH RAM)
     elseif(FAMILY STREQUAL "H7")
-        stm32h7_get_memory_info(${DEVICE} ${TYPE} ${CORE} RAM FLASH_ORIGIN_VALUE RAM_ORIGIN_VALUE)
-        set(FLASH "(${FLASH}>>1)")
+        stm32h7_get_memory_info(${INFO_DEVICE} ${INFO_TYPE} "${INFO_CORE}" RAM FLASH_ORIGIN RAM_ORIGIN TWO_FLASH_BANKS)
+        if(TWO_FLASH_BANKS)
+            string(REGEX MATCH "([0-9]+)K" FLASH_KB ${FLASH})
+            math(EXPR FLASH_KB "${CMAKE_MATCH_1} / 2")
+            set(FLASH "${FLASH_KB}K")   
+        endif()
     endif()
-
-    set(${FLASH_SIZE} ${FLASH} PARENT_SCOPE)
-    set(${RAM_SIZE} ${RAM} PARENT_SCOPE)
-    set(${CCRAM_SIZE} ${CCRAM} PARENT_SCOPE)
-    if (RAM STREQUAL "2K")
-        # Potato MCUs
-        set(${STACK_SIZE} 0x200 PARENT_SCOPE)
-        set(${HEAP_SIZE} 0x100 PARENT_SCOPE)
-    else()
-        set(${STACK_SIZE} 0x400 PARENT_SCOPE)
-        set(${HEAP_SIZE} 0x200 PARENT_SCOPE)
+    
+    if(INFO_FLASH)
+        set(SIZE ${FLASH})
+        set(ORIGIN ${FLASH_ORIGIN})
+    elseif(INFO_RAM)
+        set(SIZE ${RAM})
+        set(ORIGIN ${RAM_ORIGIN})
+    elseif(INFO_CCRAM)
+        set(SIZE ${CCRAM})
+        set(ORIGIN ${CCRAM_ORIGIN})
+    elseif(INFO_STACK)
+        if (RAM STREQUAL "2K")
+            set(SIZE 0x200)
+        else()
+            set(SIZE 0x400)
+        endif()
+        set(ORIGIN ${RAM_ORIGIN}) #TODO: Real stack pointer?
+    elseif(INFO_HEAP)
+        if (RAM STREQUAL "2K")
+            set(SIZE 0x100)
+        else()
+            set(SIZE 0x200)
+        endif()
+        set(ORIGIN ${RAM_ORIGIN}) #TODO: Real heap pointer?
+    endif()
+    
+    if(INFO_SIZE)
+        set(${INFO_SIZE} ${SIZE} PARENT_SCOPE)
+    endif()
+    if(INFO_ORIGIN)
+        set(${INFO_ORIGIN} ${ORIGIN} PARENT_SCOPE)
     endif()
-    set(${FLASH_ORIGIN} ${FLASH_ORIGIN_VALUE} PARENT_SCOPE)
-    set(${RAM_ORIGIN} ${RAM_ORIGIN_VALUE} PARENT_SCOPE)
-    set(${CCRAM_ORIGIN} ${CCRAM_ORIGIN_VALUE} PARENT_SCOPE)
 endfunction()
 
 function(stm32_add_linker_script TARGET VISIBILITY SCRIPT)

cmake/stm32/devices.cmake

@@ -1052,9 +1052,14 @@ set(STM32_ALL_DEVICES
     WLE5JC
 )
 
-function(stm32_get_devices_by_family FAMILY DEVICES)
+function(stm32_get_devices_by_family DEVICES)
+    set(ARG_OPTIONS "")
+    set(ARG_SINGLE FAMILY)
+    set(ARG_MULTIPLE "")
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "${ARG_OPTIONS}" "${ARG_SINGLE}" "${ARG_MULTIPLE}")
     set(LIST ${STM32_ALL_DEVICES})
-    list(FILTER LIST INCLUDE REGEX "^${FAMILY}")
+    if(ARG_FAMILY)
+        list(FILTER LIST INCLUDE REGEX "^${ARG_FAMILY}")
+    endif()
     set(${DEVICES} ${LIST} PARENT_SCOPE)
 endfunction()
-

cmake/stm32/h7.cmake

@@ -1,5 +1,3 @@
-# Only CM7 core is supported for now...
-
 set(STM32_H7_TYPES 
     H743xx H753xx H750xx H742xx H745xx H755xx H747xx H757xx
     H7A3xx H7A3xxQ H7B3xx H7B3xxQ H7B0xx H7B0xxQ
@@ -22,6 +20,14 @@ set(STM32_H7_CCRAM_SIZES
       0K   0K   0K   0K   0K   0K
 )
 
+set(STM32_H7_NO_FLASH_SPLIT
+      H750xx H7B0xx
+)
+
+set(STM32_H7_DUAL_CORE
+      H745xx H755xx H747xx H757xx
+)
+
 stm32_util_create_family_targets(H7 M7)
 
 target_compile_options(STM32::H7::M7 INTERFACE 
@@ -46,14 +52,22 @@ target_compile_definitions(STM32::H7::M4 INTERFACE
     -DCORE_CM4
 )
 
-function(stm32h7_get_memory_info DEVICE TYPE CORE RAM FLASH_ORIGIN RAM_ORIGIN)
+function(stm32h7_get_memory_info DEVICE TYPE CORE RAM FLASH_ORIGIN RAM_ORIGIN TWO_FLASH_BANKS)
+    if(${TYPE} IN_LIST STM32_H7_NO_FLASH_SPLIT)
+        set(${TWO_FLASH_BANKS} FALSE PARENT_SCOPE)  
+    else()
+        set(${TWO_FLASH_BANKS} TRUE PARENT_SCOPE)
+    endif()
+    if(NOT CORE)
+        set(CORE "M7")
+    endif()
     list(FIND STM32_H7_TYPES ${TYPE} TYPE_INDEX)
-    if(CORE STREQUAL "_M7")
+    if(CORE STREQUAL "M7")
         list(GET STM32_H7_RAM_SIZES ${TYPE_INDEX} RAM_VALUE)
         set(${RAM} ${RAM_VALUE} PARENT_SCOPE)
         set(${FLASH_ORIGIN} 0x8000000 PARENT_SCOPE)
         set(${RAM_ORIGIN} 0x20000000 PARENT_SCOPE)
-    elseif(CORE STREQUAL "_M4")
+    elseif((${TYPE} IN_LIST STM32_H7_DUAL_CORE) AND (CORE STREQUAL "M4"))
         list(GET STM32_H7_M4_RAM_SIZES ${TYPE_INDEX} RAM_VALUE)
         set(${RAM} ${RAM_VALUE} PARENT_SCOPE)
         set(${FLASH_ORIGIN} 0x8100000 PARENT_SCOPE)
@@ -62,3 +76,11 @@ function(stm32h7_get_memory_info DEVICE TYPE CORE RAM FLASH_ORIGIN RAM_ORIGIN)
         message(FATAL_ERROR "Unknown core ${CORE}")
     endif()
 endfunction()
+
+function(stm32h7_get_device_cores DEVICE TYPE CORES)
+    if(${TYPE} IN_LIST STM32_H7_DUAL_CORE)
+        set(${CORES} M7 M4 PARENT_SCOPE)
+    else()
+        set(${CORES} M7 PARENT_SCOPE)
+    endif()
+endfunction()

tests/cmsis/CMakeLists.txt

@@ -14,15 +14,26 @@ set(SOURCES main.c)
 include(stm32/devices)
 
 foreach(FAMILY ${TEST_FAMILIES})
-    stm32_get_devices_by_family(${FAMILY} DEVICES)
-    foreach(DEVICE ${DEVICES})    
+    stm32_get_devices_by_family(DEVICES FAMILY ${FAMILY})
+    stm32_get_cores(CORES FAMILY ${FAMILY})
+    foreach(DEVICE ${DEVICES})
         stm32_get_chip_type(${FAMILY} ${DEVICE} TYPE)
-        stm32_get_memory_info(${FAMILY} ${DEVICE} "" # Use a blank core here.
-            FLASH_SIZE RAM_SIZE CCRAM_SIZE STACK_SIZE HEAP_SIZE 
-            FLASH_ORIGIN RAM_ORIGIN CCRAM_ORIGIN
-        )
-        message(STATUS "STM32${DEVICE}: ${FAMILY} family, type ${TYPE}, ${FLASH_SIZE} flash, ${RAM_SIZE} RAM")
-        add_executable(cmsis-test-${DEVICE} ${SOURCES})
-        target_link_libraries(cmsis-test-${DEVICE} CMSIS::STM32::${DEVICE} STM32::NoSys)
+        
+        if(NOT CORES)
+            stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} FLASH SIZE FLASH_SIZE)
+            stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} RAM SIZE RAM_SIZE)
+            message(STATUS "STM32${DEVICE}: ${FAMILY} family, type ${TYPE}, ${FLASH_SIZE} flash, ${RAM_SIZE} RAM")
+            add_executable(cmsis-test-${DEVICE} ${SOURCES})
+            target_link_libraries(cmsis-test-${DEVICE} CMSIS::STM32::${DEVICE} STM32::NoSys)
+        else()
+            stm32_get_cores(CORES FAMILY ${FAMILY} DEVICE ${DEVICE})
+            foreach(CORE ${DEV_CORES})
+                stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} FLASH SIZE FLASH_SIZE)
+                stm32_get_memory_info(FAMILY ${FAMILY} DEVICE ${DEVICE} CORE ${CORE} RAM SIZE RAM_SIZE)
+                message(STATUS "STM32${DEVICE}: ${FAMILY} family, type ${TYPE}, core ${CORE}, ${FLASH_SIZE} flash, ${RAM_SIZE} RAM")
+                add_executable(cmsis-test-${DEVICE}-${CORE} ${SOURCES})
+                target_link_libraries(cmsis-test-${DEVICE}-${CORE} CMSIS::STM32::${DEVICE}::${CORE} STM32::NoSys)
+            endforeach()
+        endif()
     endforeach()
 endforeach()

tests/hal/CMakeLists.txt

@@ -14,22 +14,30 @@ find_package(HAL REQUIRED)
 set(SOURCES main.c)
 
 foreach(FAMILY ${TEST_FAMILIES})
-    stm32_get_devices_by_family(${FAMILY} DEVICES)
+    stm32_get_devices_by_family(DEVICES FAMILY ${FAMILY})
     list(GET DEVICES 0 DEVICE)
+    stm32_get_cores(CORES FAMILY ${FAMILY} DEVICE ${DEVICE})
+    
+    if(CORES)
+        list(GET CORES 0 CORE)
+        set(CORE "::${CORE}")
+    else()
+        unset(CORE)
+    endif()
     
     add_executable(hal-test-${FAMILY} ${SOURCES})
     
     foreach(DRIVER ${HAL_DRIVERS_${FAMILY}})
         string(TOUPPER ${DRIVER} DRIVER)
-        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}::${DRIVER})
+        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}${CORE}::${DRIVER})
     endforeach()
     foreach(DRIVER ${HAL_EX_DRIVERS_${FAMILY}})
         string(TOUPPER ${DRIVER} DRIVER)
-        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}::${DRIVER}Ex)
+        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}${CORE}::${DRIVER}Ex)
     endforeach()
     foreach(DRIVER ${HAL_LL_DRIVERS_${FAMILY}})
         string(TOUPPER ${DRIVER} DRIVER)
-        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}::LL_${DRIVER})
+        target_link_libraries(hal-test-${FAMILY} HAL::STM32::${FAMILY}${CORE}::LL_${DRIVER})
     endforeach()
-    target_link_libraries(hal-test-${FAMILY} STM32::NoSys CMSIS::STM32::${DEVICE})
+    target_link_libraries(hal-test-${FAMILY} STM32::NoSys CMSIS::STM32::${DEVICE}${CORE})
 endforeach()