Add support for STM32H7's dual cores

For the H7 family of chips, there's now an additional level of nesting
for M7 or M4 depending on which core you are targeting.

README.md

@@ -114,6 +114,6 @@ 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 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_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
 

cmake/FindCMSIS.cmake

@@ -9,12 +9,13 @@ endif()
 
 include(stm32/devices)
     
-function(cmsis_generate_default_linker_script FAMILY DEVICE)
-    stm32_get_memory_info(${FAMILY} ${DEVICE} 
+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}.ld"
+    add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld"
         COMMAND ${CMAKE_COMMAND} 
             -DFLASH_ORIGIN="${FLASH_ORIGIN}" 
             -DRAM_ORIGIN="${RAM_ORIGIN}" 
@@ -24,19 +25,19 @@ function(cmsis_generate_default_linker_script FAMILY DEVICE)
             -DCCRAM_SIZE="${CCRAM_SIZE}" 
             -DSTACK_SIZE="${STACK_SIZE}" 
             -DHEAP_SIZE="${HEAP_SIZE}" 
-            -DLINKER_SCRIPT="${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}.ld"
+            -DLINKER_SCRIPT="${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}${CORE}.ld"
             -P "${STM32_CMAKE_DIR}/stm32/linker_ld.cmake"
     )
-    add_custom_target(CMSIS_LD_${DEVICE} DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}.ld)
-    add_dependencies(CMSIS::STM32::${DEVICE} CMSIS_LD_${DEVICE})
-    stm32_add_linker_script(CMSIS::STM32::${DEVICE} INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/${DEVICE}.ld")
+    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")
 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])?.*$" 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}")
@@ -49,6 +50,10 @@ foreach(COMP ${CMSIS_FIND_COMPONENTS})
         set(FAMILY ${CMAKE_MATCH_1})
         stm32_get_devices_by_family(${FAMILY} DEVICES)
     endif()
+    if(CMAKE_MATCH_3)
+        set(CORE ${CMAKE_MATCH_3})
+        string(REGEX REPLACE "_" "::" CORE_C ${CORE})
+    endif()
     string(TOLOWER ${FAMILY} FAMILY_L)
     
     if(NOT STM32_CUBE_${FAMILY}_PATH)
@@ -56,67 +61,67 @@ foreach(COMP ${CMSIS_FIND_COMPONENTS})
         message(STATUS "No STM32_CUBE_${FAMILY}_PATH specified using default: ${STM32_CUBE_${FAMILY}_PATH}")
     endif()
         
-    find_path(CMSIS_${FAMILY}_PATH
+    find_path(CMSIS_${FAMILY}${CORE}_PATH
         NAMES Include/cmsis_gcc.h
         PATHS "${STM32_CUBE_${FAMILY}_PATH}/Drivers/CMSIS"
         NO_DEFAULT_PATH
     )
-    if (NOT CMSIS_${FAMILY}_PATH)
+    if (NOT CMSIS_${FAMILY}${CORE}_PATH)
         continue()
     endif()
     
-    if(NOT CMSIS_${FAMILY}_VERSION)
-        find_file(CMSIS_${FAMILY}_PDSC
+    if(NOT CMSIS_${FAMILY}${CORE}_VERSION)
+        find_file(CMSIS_${FAMILY}${CORE}_PDSC
             NAMES ARM.CMSIS.pdsc
-            PATHS "${CMSIS_${FAMILY}_PATH}"
+            PATHS "${CMSIS_${FAMILY}${CORE}_PATH}"
             NO_DEFAULT_PATH
         )
-        if (NOT CMSIS_${FAMILY}_PDSC)
-            set(CMSIS_${FAMILY}_VERSION "0.0.0")
+        if (NOT CMSIS_${FAMILY}${CORE}_PDSC)
+            set(CMSIS_${FAMILY}${CORE}_VERSION "0.0.0")
         else()
-            file(STRINGS "${CMSIS_${FAMILY}_PDSC}" VERSION_STRINGS REGEX "<release version=\"([0-9]*\\.[0-9]*\\.[0-9]*)\" date=\"[0-9]+\\-[0-9]+\\-[0-9]+\">")
+            file(STRINGS "${CMSIS_${FAMILY}${CORE}_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}_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" CACHE INTERNAL "CMSIS STM32${FAMILY} version")
+            set(CMSIS_${FAMILY}${CORE}_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" CACHE INTERNAL "CMSIS STM32${FAMILY}${CORE} version")
         endif()
     endif()
     
-    set(CMSIS_${COMP}_VERSION ${CMSIS_${FAMILY}_VERSION})
+    set(CMSIS_${COMP}_VERSION ${CMSIS_${FAMILY}${CORE}_VERSION})
     set(CMSIS_VERSION ${CMSIS_${COMP}_VERSION})
     
-    find_path(CMSIS_${FAMILY}_COMMON_INCLUDE
+    find_path(CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE
         NAMES cmsis_gcc.h
-        PATHS "${CMSIS_${FAMILY}_PATH}/Include"
+        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Include"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}_COMMON_INCLUDE}")
+    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE}")
     
-    find_path(CMSIS_${FAMILY}_INCLUDE
+    find_path(CMSIS_${FAMILY}${CORE}_INCLUDE
         NAMES stm32${FAMILY_L}xx.h
-        PATHS "${CMSIS_${FAMILY}_PATH}/Device/ST/STM32${FAMILY}xx/Include"
+        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Include"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}_INCLUDE}")
+    list(APPEND CMSIS_INCLUDE_DIRS "${CMSIS_${FAMILY}${CORE}_INCLUDE}")
     
-    find_file(CMSIS_${FAMILY}_SOURCE
+    find_file(CMSIS_${FAMILY}${CORE}_SOURCE
         NAMES system_stm32${FAMILY_L}xx.c
-        PATHS "${CMSIS_${FAMILY}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates"
+        PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates"
         NO_DEFAULT_PATH
     )
-    list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}_SOURCE}")
+    list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE}_SOURCE}")
     
-    if ((NOT CMSIS_${FAMILY}_COMMON_INCLUDE) OR 
-        (NOT CMSIS_${FAMILY}_INCLUDE) OR 
-        (NOT CMSIS_${FAMILY}_SOURCE))
+    if ((NOT CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE) OR 
+        (NOT CMSIS_${FAMILY}${CORE}_INCLUDE) OR 
+        (NOT CMSIS_${FAMILY}${CORE}_SOURCE))
         continue()
     endif()
 
-    if(NOT (TARGET CMSIS::STM32::${FAMILY}))
-        add_library(CMSIS::STM32::${FAMILY} INTERFACE IMPORTED)
-        target_link_libraries(CMSIS::STM32::${FAMILY} INTERFACE STM32::${FAMILY})
-        target_include_directories(CMSIS::STM32::${FAMILY} INTERFACE "${CMSIS_${FAMILY}_COMMON_INCLUDE}")
-        target_include_directories(CMSIS::STM32::${FAMILY} INTERFACE "${CMSIS_${FAMILY}_INCLUDE}")
-        target_sources(CMSIS::STM32::${FAMILY} INTERFACE "${CMSIS_${FAMILY}_SOURCE}")
+    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}")
     endif()
 
     set(DEVICES_FOUND TRUE)
@@ -125,36 +130,38 @@ foreach(COMP ${CMSIS_FIND_COMPONENTS})
         string(TOLOWER ${DEVICE} DEVICE_L)
         string(TOLOWER ${TYPE} TYPE_L)
         
-        find_file(CMSIS_${FAMILY}_${TYPE}_STARTUP
+        find_file(CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP
             NAMES startup_stm32${TYPE_L}.s
-            PATHS "${CMSIS_${FAMILY}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates/gcc"
+            PATHS "${CMSIS_${FAMILY}${CORE}_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates/gcc"
             NO_DEFAULT_PATH
         )
-        list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}_${TYPE}_STARTUP}")
-        if(NOT CMSIS_${FAMILY}_${TYPE}_STARTUP)
+        list(APPEND CMSIS_SOURCES "${CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP}")
+        if(NOT CMSIS_${FAMILY}${CORE}_${TYPE}_STARTUP)
             set(DEVICES_FOUND FALSE)
             break()
         endif()
         
-        if(NOT (TARGET CMSIS::STM32::${TYPE}))
-            add_library(CMSIS::STM32::${TYPE} INTERFACE IMPORTED)
-            target_link_libraries(CMSIS::STM32::${TYPE} INTERFACE CMSIS::STM32::${FAMILY} STM32::${TYPE})
-            target_sources(CMSIS::STM32::${TYPE} INTERFACE "${CMSIS_${FAMILY}_${TYPE}_STARTUP}")
+        if(NOT (TARGET CMSIS::STM32::${TYPE}${CORE}))
+            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}")
         endif()
         
-        add_library(CMSIS::STM32::${DEVICE} INTERFACE IMPORTED)
-        target_link_libraries(CMSIS::STM32::${DEVICE} INTERFACE CMSIS::STM32::${TYPE})
-        cmsis_generate_default_linker_script(${FAMILY} ${DEVICE})
+        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})
     endforeach()
         
-    if(CMSIS_${FAMILY}_COMMON_INCLUDE AND 
-       CMSIS_${FAMILY}_INCLUDE AND 
-       CMSIS_${FAMILY}_SOURCE AND
+    if(CMSIS_${FAMILY}${CORE}_COMMON_INCLUDE AND 
+       CMSIS_${FAMILY}${CORE}_INCLUDE AND 
+       CMSIS_${FAMILY}${CORE}_SOURCE AND
        DEVICES_FOUND)
        set(CMSIS_${COMP}_FOUND TRUE)
     else()
        set(CMSIS_${COMP}_FOUND FALSE)
     endif()
+    list(REMOVE_DUPLICATES CMSIS_INCLUDE_DIRS)
+    list(REMOVE_DUPLICATES CMSIS_SOURCES)
 endforeach()
 
 include(FindPackageHandleStandardArgs)

cmake/FindHAL.cmake

@@ -170,11 +170,16 @@ 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})
     
     if(NOT CMAKE_MATCH_1)
         message(FATAL_ERROR "Unknown HAL component: ${COMP}")
     endif()
+
+    if(CORE)
+        string(REPLACE "_" "::" CORE_C "${CORE}")
+    endif()
         
     set(FAMILY ${CMAKE_MATCH_1})
     string(TOLOWER ${FAMILY} FAMILY_L)
@@ -193,64 +198,64 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
         continue()
     endif()
     
-    find_path(HAL_${FAMILY}_INCLUDE
+    find_path(HAL_${FAMILY}${CORE}_INCLUDE
         NAMES stm32${FAMILY_L}xx_hal.h
         PATHS "${HAL_${FAMILY}_PATH}/Inc"
         NO_DEFAULT_PATH
     )
-    find_file(HAL_${FAMILY}_SOURCE
+    find_file(HAL_${FAMILY}${CORE}_SOURCE
         NAMES stm32${FAMILY_L}xx_hal.c
         PATHS "${HAL_${FAMILY}_PATH}/Src"
         NO_DEFAULT_PATH
     )
     
-    if ((NOT HAL_${FAMILY}_INCLUDE) OR (NOT HAL_${FAMILY}_SOURCE))
+    if ((NOT HAL_${FAMILY}${CORE}_INCLUDE) OR (NOT HAL_${FAMILY}${CORE}_SOURCE))
         set(HAL_${COMP}_FOUND FALSE)
         continue()
     endif()
 
-    if(NOT (TARGET HAL::STM32::${FAMILY}))
-        add_library(HAL::STM32::${FAMILY} INTERFACE IMPORTED)
-        target_link_libraries(HAL::STM32::${FAMILY} INTERFACE STM32::${FAMILY} CMSIS::STM32::${FAMILY})
-        target_include_directories(HAL::STM32::${FAMILY} INTERFACE "${HAL_${FAMILY}_INCLUDE}")
-        target_sources(HAL::STM32::${FAMILY} INTERFACE "${HAL_${FAMILY}_SOURCE}")
+    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}")
     endif()
     
     foreach(DRV ${HAL_DRIVERS_${FAMILY}})
         string(TOLOWER ${DRV} DRV_L)
         string(TOUPPER ${DRV} DRV)
         
-        find_file(HAL_${FAMILY}_${DRV}_SOURCE
+        find_file(HAL_${FAMILY}${CORE}_${DRV}_SOURCE
             NAMES stm32${FAMILY_L}xx_hal_${DRV_L}.c
             PATHS "${HAL_${FAMILY}_PATH}/Src"
             NO_DEFAULT_PATH
         )
-        list(APPEND HAL_${FAMILY}_SOURCES "${HAL_${FAMILY}_${DRV}_SOURCE}")
-        if(NOT HAL_${FAMILY}_${DRV}_SOURCE)
+        list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}_${DRV}_SOURCE}")
+        if(NOT HAL_${FAMILY}${CORE}_${DRV}_SOURCE)
             message(WARNING "Cannot find ${DRV} driver for ${COMP}")
         endif()
                 
-        if(HAL_${FAMILY}_${DRV}_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}::${DRV})))
-            add_library(HAL::STM32::${FAMILY}::${DRV} INTERFACE IMPORTED)
-            target_link_libraries(HAL::STM32::${FAMILY}::${DRV} INTERFACE HAL::STM32::${FAMILY})
-            target_sources(HAL::STM32::${FAMILY}::${DRV} INTERFACE "${HAL_${FAMILY}_${DRV}_SOURCE}")
+        if(HAL_${FAMILY}${CORE}_${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}")
         endif()
                 
-        if(HAL_${FAMILY}_${DRV}_SOURCE AND (${DRV_L} IN_LIST HAL_EX_DRIVERS_${FAMILY}))
-            find_file(HAL_${FAMILY}_${DRV}_EX_SOURCE
+        if(HAL_${FAMILY}${CORE}_${DRV}_SOURCE AND (${DRV_L} IN_LIST HAL_EX_DRIVERS_${FAMILY}))
+            find_file(HAL_${FAMILY}${CORE}_${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}_SOURCES "${HAL_${FAMILY}_${DRV}_EX_SOURCE}")
-            if(NOT HAL_${FAMILY}_${DRV}_EX_SOURCE)
+            list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE}")
+            if(NOT HAL_${FAMILY}${CORE}_${DRV}_EX_SOURCE)
                 message(WARNING "Cannot find ${DRV}Ex driver for ${COMP}")
             endif()
             
-            if((TARGET HAL::STM32::${FAMILY}::${DRV}) AND (NOT (TARGET HAL::STM32::${FAMILY}::${DRV}Ex)))
-                add_library(HAL::STM32::${FAMILY}::${DRV}Ex INTERFACE IMPORTED)
-                target_link_libraries(HAL::STM32::${FAMILY}::${DRV}Ex INTERFACE HAL::STM32::${FAMILY}::${DRV})
-                target_sources(HAL::STM32::${FAMILY}::${DRV}Ex INTERFACE "${HAL_${FAMILY}_${DRV}_EX_SOURCE}")
+            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}")
             endif()
         endif()
     endforeach()
@@ -259,25 +264,25 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
         string(TOLOWER ${DRV} DRV_L)
         string(TOUPPER ${DRV} DRV)
         
-        find_file(HAL_${FAMILY}_${DRV}_LL_SOURCE
+        find_file(HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE
             NAMES stm32${FAMILY_L}xx_ll_${DRV_L}.c
             PATHS "${HAL_${FAMILY}_PATH}/Src"
             NO_DEFAULT_PATH
         )
-        list(APPEND HAL_${FAMILY}_SOURCES "${HAL_${FAMILY}_${DRV}_LL_SOURCE}")
-        if(NOT HAL_${FAMILY}_${DRV}_LL_SOURCE)
+        list(APPEND HAL_${FAMILY}${CORE}_SOURCES "${HAL_${FAMILY}_${DRV}_LL_SOURCE}")
+        if(NOT HAL_${FAMILY}${CORE}_${DRV}_LL_SOURCE)
             message(WARNING "Cannot find LL_${DRV} driver for ${COMP}")
         endif()
     
-        if(HAL_${FAMILY}_${DRV}_LL_SOURCE AND (NOT (TARGET HAL::STM32::${FAMILY}::LL_${DRV})))
-            add_library(HAL::STM32::${FAMILY}::LL_${DRV} INTERFACE IMPORTED)
-            target_link_libraries(HAL::STM32::${FAMILY}::LL_${DRV} INTERFACE HAL::STM32::${FAMILY})
-            target_sources(HAL::STM32::${FAMILY}::LL_${DRV} INTERFACE "${HAL_${FAMILY}_${DRV}_LL_SOURCE}")
+        if(HAL_${FAMILY}${CORE}_${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}")
         endif()
     endforeach()
     
     set(HAL_${COMP}_FOUND TRUE)
-    foreach(FILE ${HAL_${FAMILY}_SOURCES})
+    foreach(FILE ${HAL_${FAMILY}${CORE}_SOURCES})
         if(NOT FILE)
             set(HAL_${COMP}_FOUND FALSE)
             break()
@@ -285,9 +290,11 @@ foreach(COMP ${HAL_FIND_COMPONENTS})
     endforeach()
         
     if(HAL_${COMP}_FOUND)
-        list(APPEND HAL_INCLUDE_DIRS "${HAL_${FAMILY}_INCLUDE}")
-        list(APPEND HAL_SOURCES "${HAL_${FAMILY}_SOURCES}")
+        list(APPEND HAL_INCLUDE_DIRS "${HAL_${FAMILY}${CORE}_INCLUDE}")
+        list(APPEND HAL_SOURCES "${HAL_${FAMILY}${CORE}_SOURCES}")
     endif()
+    list(REMOVE_DUPLICATES HAL_INCLUDE_DIRS)
+    list(REMOVE_DUPLICATES HAL_SOURCES)
 endforeach()
 
 include(FindPackageHandleStandardArgs)

cmake/stm32/common.cmake

@@ -65,7 +65,7 @@ function(stm32_get_chip_info CHIP FAMILY TYPE DEVICE)
     set(${TYPE} ${STM32_TYPE} PARENT_SCOPE)
 endfunction()
 
-function(stm32_get_memory_info FAMILY DEVICE 
+function(stm32_get_memory_info FAMILY DEVICE CORE
     FLASH_SIZE RAM_SIZE CCRAM_SIZE STACK_SIZE HEAP_SIZE 
     FLASH_ORIGIN RAM_ORIGIN CCRAM_ORIGIN
 )
@@ -106,6 +106,9 @@ function(stm32_get_memory_info FAMILY DEVICE
     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)
     
     if(FAMILY STREQUAL "F1")
         stm32f1_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
@@ -115,6 +118,9 @@ function(stm32_get_memory_info FAMILY DEVICE
         stm32f2_get_memory_info(${DEVICE} ${TYPE} FLASH RAM)
     elseif(FAMILY STREQUAL "F3")
         stm32f3_get_memory_info(${DEVICE} ${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)")
     endif()
 
     set(${FLASH_SIZE} ${FLASH} PARENT_SCOPE)
@@ -128,9 +134,9 @@ function(stm32_get_memory_info FAMILY DEVICE
         set(${STACK_SIZE} 0x400 PARENT_SCOPE)
         set(${HEAP_SIZE} 0x200 PARENT_SCOPE)
     endif()
-    set(${FLASH_ORIGIN} 0x8000000 PARENT_SCOPE)
-    set(${RAM_ORIGIN} 0x20000000 PARENT_SCOPE)
-    set(${CCRAM_ORIGIN} 0x10000000 PARENT_SCOPE)
+    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/h7.cmake

@@ -12,19 +12,53 @@ set(STM32_H7_RAM_SIZES
     128K 128K 128K 128K 128K 128K 128K 128K
     128K 128K 128K 128K 128K 128K 
 )
+set(STM32_H7_M4_RAM_SIZES
+    288K 288K 288K 288K 288K 288K 288K 288K
+    288K 288K 288K 288K 288K 288K 
+)
+
 set(STM32_H7_CCRAM_SIZES 
       0K   0K   0K   0K   0K   0K   0K   0K
       0K   0K   0K   0K   0K   0K
 )
 
-stm32_util_create_family_targets(H7)
+stm32_util_create_family_targets(H7 M7)
 
-target_compile_options(STM32::H7 INTERFACE 
+target_compile_options(STM32::H7::M7 INTERFACE 
     -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=hard
 )
-target_link_options(STM32::H7 INTERFACE 
+target_link_options(STM32::H7::M7 INTERFACE 
     -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=hard
 )
-target_compile_definitions(STM32::H7 INTERFACE 
+target_compile_definitions(STM32::H7::M7 INTERFACE 
     -DCORE_CM7
 )
+
+stm32_util_create_family_targets(H7 M4)
+
+target_compile_options(STM32::H7::M4 INTERFACE 
+    -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+)
+target_link_options(STM32::H7::M4 INTERFACE 
+    -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+)
+target_compile_definitions(STM32::H7::M4 INTERFACE 
+    -DCORE_CM4
+)
+
+function(stm32h7_get_memory_info DEVICE TYPE CORE RAM FLASH_ORIGIN RAM_ORIGIN)
+    list(FIND STM32_H7_TYPES ${TYPE} TYPE_INDEX)
+    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")
+        list(GET STM32_H7_M4_RAM_SIZES ${TYPE_INDEX} RAM_VALUE)
+        set(${RAM} ${RAM_VALUE} PARENT_SCOPE)
+        set(${FLASH_ORIGIN} 0x8100000 PARENT_SCOPE)
+        set(${RAM_ORIGIN} 0x10000000 PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Unknown core ${CORE}")
+    endif()
+endfunction()

cmake/stm32/utilities.cmake

@@ -1,27 +1,39 @@
 function(stm32_util_create_family_targets FAMILY)
-    if(NOT (TARGET STM32::${FAMILY}))
-        add_library(STM32::${FAMILY} INTERFACE IMPORTED)
-        target_compile_options(STM32::${FAMILY} INTERFACE 
+    set(CORES ${ARGN})
+    list(LENGTH CORES NUM_CORES)
+    if(${NUM_CORES} EQUAL 0)
+        set(CORE "")
+        set(CORE_C "")
+    elseif(${NUM_CORES} EQUAL 1)
+        set(CORE "_${CORES}")
+        set(CORE_C "::${CORES}")
+    else()
+        message(FATAL_ERROR "Expected at most one core for family ${FAMILY}: ${CORES}")
+    endif()
+
+    if(NOT (TARGET STM32::${FAMILY}${CORE_C}))
+        add_library(STM32::${FAMILY}${CORE_C} INTERFACE IMPORTED)
+        target_compile_options(STM32::${FAMILY}${CORE_C} INTERFACE 
             --sysroot="${TOOLCHAIN_SYSROOT}"
             -mthumb -mabi=aapcs -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin -ffast-math
             $<$<CONFIG:Debug>:-Og>
             $<$<CONFIG:Release>:-Os>
         )
-        target_link_options(STM32::${FAMILY} INTERFACE 
+        target_link_options(STM32::${FAMILY}${CORE_C} INTERFACE 
             --sysroot="${TOOLCHAIN_SYSROOT}"
             -mthumb -mabi=aapcs -Wl,--gc-sections
             $<$<CONFIG:Debug>:-Og>
             $<$<CONFIG:Release>:-Os -s>
         )
-        target_compile_definitions(STM32::${FAMILY} INTERFACE 
+        target_compile_definitions(STM32::${FAMILY}${CORE_C} INTERFACE 
             STM32${FAMILY}
         )
     endif()
     foreach(TYPE ${STM32_${FAMILY}_TYPES})
-        if(NOT (TARGET STM32::${TYPE}))
-            add_library(STM32::${TYPE} INTERFACE IMPORTED)
-            target_link_libraries(STM32::${TYPE} INTERFACE STM32::${FAMILY})
-            target_compile_definitions(STM32::${TYPE} INTERFACE 
+        if(NOT (TARGET STM32::${TYPE}${CORE_C}))
+            add_library(STM32::${TYPE}${CORE_C} INTERFACE IMPORTED)
+            target_link_libraries(STM32::${TYPE}${CORE_C} INTERFACE STM32::${FAMILY}${CORE_C})
+            target_compile_definitions(STM32::${TYPE}${CORE_C} INTERFACE 
                 STM32${TYPE}
             )
         endif()

tests/cmsis/CMakeLists.txt

@@ -17,7 +17,7 @@ foreach(FAMILY ${TEST_FAMILIES})
     stm32_get_devices_by_family(${FAMILY} DEVICES)
     foreach(DEVICE ${DEVICES})    
         stm32_get_chip_type(${FAMILY} ${DEVICE} TYPE)
-        stm32_get_memory_info(${FAMILY} ${DEVICE} 
+        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
         )