config/kconfig.cmake

#-------------------------------------------------------------------------------
# Copyright (c) 2022-2023, Arm Limited. All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
#
#-------------------------------------------------------------------------------

# Load multiple config files and merge into one, generates CMake config file and config header file.
# The first loaded configs would be overridden by later ones. That's how the "merge" works.
# Check CONFIG_FILE_LIST for the loading order.
# Configurations not set by any of the config files would be set to the default values in Kconfig
# files with dependencies respected.
# If a ".config" already exists in the output folder, then the CONFIG_FILE_LIST is ignored.
# For more details, check the kconfig_system.rst.

set(KCONFIG_OUTPUT_DIR  ${CMAKE_BINARY_DIR}/kconfig)

set(DOTCONFIG_FILE      ${KCONFIG_OUTPUT_DIR}/.config)
set(ROOT_KCONFIG        ${CMAKE_SOURCE_DIR}/Kconfig)
set(PLATFORM_KCONFIG    ${TARGET_PLATFORM_PATH}/Kconfig)

if(TFM_PROFILE)
    # Selecting TF-M profiles is not supported yet.
    message(FATAL_ERROR "Selecting TF-M profiles is not supported yet in Kconfig system!")
endif()

# This function parses the input ${cmake_file} to get normal CMake variables and their values in the
# format of "set(_VAR_ _VALUE_)". The format could be split into multiple lines.
# Note that CMake does not allow the "(" to be in a different line as "set" and no white spaces are
# recommanded between "set" and "(". So the function only covers format of "set(".
function(convert_normal_cmake_config_to_kconfig cmake_file out_var)
    # Operate on a local var and write back to the "out_var" later.
    set(local_var "")

    # Read out the strings of the file. Binary data in the file are ignored
    file(STRINGS ${cmake_file} CONTENTS)

    # Exclude lines of comments (started with "#")
    set(CONTENTS_WITHOUT_COMMENTS "")

    foreach(LINE ${CONTENTS})
        string(REGEX MATCH "^#.*" OUT_STRING ${LINE})
        if(NOT OUT_STRING)
            string(APPEND CONTENTS_WITHOUT_COMMENTS "${LINE}\n")
        endif()
    endforeach()

    # Search for strings match set(_VAR_ _VALUE_) with support of multi-line format
    string(REGEX MATCHALL
           "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*([^ \t\r\n]*)[ \t\r\n]*\\)"
           OUT_STRINGS ${CONTENTS_WITHOUT_COMMENTS})

    foreach(MATCHED_ITEM ${OUT_STRINGS})
        # Try to convert CMake format to Kconfig one
        # If the format does not match, the content will not be changed and fall down to the next

        # Bool types
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*(TRUE|ON)[ \t\r\n]*\\)"
               "config \\1\n default y\n"
               MATCHED_ITEM ${MATCHED_ITEM})
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*(FALSE|OFF)[ \t\r\n]*\\)"
               "config \\1\n default n\n"
               MATCHED_ITEM ${MATCHED_ITEM})
        # Hex int
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*(0x[0-9a-fA-F]+[ \t\r\n]*)\\)"
               "config \\1\n default \\2\n"
               MATCHED_ITEM ${MATCHED_ITEM})
        # Decimal int
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*([0-9]+)[ \t\r\n]*\\)"
               "config \\1\n default \\2\n"
               MATCHED_ITEM ${MATCHED_ITEM})
        # Quoted string
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*(\".*\")[ \t\r\n]*\\)"
               "config \\1\n default \\2\n"
               MATCHED_ITEM ${MATCHED_ITEM})
        # If none of the above matches, must be a non-quoted string
        string(REGEX REPLACE
               "set\\([ \t\r\n]*([A-Za-z0-9_]*)[ \t\r\n]*(.*)[ \t\r\n]*\\)"
               "config \\1\n default \"\\2\"\n"
               MATCHED_ITEM ${MATCHED_ITEM})

        string(APPEND local_var ${MATCHED_ITEM})
    endforeach()

    set(${out_var} ${local_var} PARENT_SCOPE)
endfunction()

# Platform Kconfig file
if(NOT EXISTS ${PLATFORM_KCONFIG})
    message(WARNING "The platform does not have Kconfig file! \
                     The Kconfig system cannot get its configuration settings.
                     So it is not guaranteed that the Kconfig system works properly.")

    # Parse platform's preload.cmake and config.cmake to get config options.
    set(PLATFORM_KCONFIG_OPTIONS "")
    set(PLATFORM_KCONFIG ${KCONFIG_OUTPUT_DIR}/platform/Kconfig)

    convert_normal_cmake_config_to_kconfig(${TARGET_PLATFORM_PATH}/preload.cmake PLATFORM_KCONFIG_OPTIONS)
    file(WRITE ${PLATFORM_KCONFIG} ${PLATFORM_KCONFIG_OPTIONS})

    if(EXISTS ${TARGET_PLATFORM_PATH}/config.cmake)
        include(${TARGET_PLATFORM_PATH}/config.cmake)
        convert_normal_cmake_config_to_kconfig(${TARGET_PLATFORM_PATH}/config.cmake PLATFORM_KCONFIG_OPTIONS)
        file(APPEND ${PLATFORM_KCONFIG} ${PLATFORM_KCONFIG_OPTIONS})
    endif()
endif()
get_filename_component(PLATFORM_KCONFIG_PATH ${PLATFORM_KCONFIG} DIRECTORY)

# User customized config file
if(DEFINED KCONFIG_CONFIG_FILE AND NOT EXISTS ${KCONFIG_CONFIG_FILE})
    message(FATAL_ERROR "No such file: ${KCONFIG_CONFIG_FILE}")
endif()

# Note the order of CONFIG_FILE_LIST, as the first loaded configs would be
# overridden by later ones.
list(APPEND CONFIG_FILE_LIST
            ${KCONFIG_CONFIG_FILE})

# Set up ENV variables for the tfm_kconfig.py which are then consumed by Kconfig files.
set(KCONFIG_ENV_VARS "TFM_SOURCE_DIR=${CMAKE_SOURCE_DIR} \
                      TFM_VERSION=${TFM_VERSION} \
                      PLATFORM_PATH=${PLATFORM_KCONFIG_PATH} \
                      CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")

if(MENUCONFIG)
    # Note: Currently, only GUI menuconfig can be supported with CMake integration
    set(MENUCONFIG_ARG "-u=gui")
else()
    set(MENUCONFIG_ARG "")
endif()

if(DEFINED PROJECT_CONFIG_HEADER_FILE)
    get_property(HELP_STRING CACHE PROJECT_CONFIG_HEADER_FILE PROPERTY HELPSTRING)

    # It is not supported to set PROJECT_CONFIG_HEADER_FILE while using Kconfig, either from
    # command line or CMake files. It should be set to the file generated the Kconfig system.
    # As this file set it itself, if the user re-run the CMake config command, the
    # PROJECT_CONFIG_HEADER_FILE will be already defined set.
    # So the existence of the ${DOTCONFIG_FILE} is used to indicate if it is a re-configuration.
    if("${HELP_STRING}" MATCHES "variable specified on the command line" OR NOT EXISTS ${DOTCONFIG_FILE})
        message(FATAL_ERROR "It is NOT supported to manually set PROJECT_CONFIG_HEADER_FILE while using Kconfig.")
    endif()
endif()

find_package(Python3)

execute_process(
    COMMAND
    ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/kconfig/tfm_kconfig.py
    -k ${ROOT_KCONFIG} -o ${KCONFIG_OUTPUT_DIR}
    --envs ${KCONFIG_ENV_VARS}
    --config-files ${CONFIG_FILE_LIST}
    ${MENUCONFIG_ARG}
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    RESULT_VARIABLE ret
)

if(NOT ret EQUAL 0)
    message(FATAL_ERROR "Kconfig tool failed!")
endif()

# Component configs generated by tfm_kconfig.py
set(PROJECT_CONFIG_HEADER_FILE ${KCONFIG_OUTPUT_DIR}/project_config.h CACHE FILEPATH "User defined header file for TF-M config")

# Load project cmake configs generated by tfm_kconfig.py
include(${KCONFIG_OUTPUT_DIR}/project_config.cmake)

####################################################################################################

# The Kconfig system does not cover all the config options for the time being.
# So part of them still use the CMake config system.

# Load regression configs overrided by platform
if(EXISTS ${TARGET_PLATFORM_PATH}/reg_config_override.cmake)
    include(${TARGET_PLATFORM_PATH}/reg_config_override.cmake)
endif()

# Load build type config, setting options not already set
if(EXISTS ${CMAKE_SOURCE_DIR}/config/build_type/${CMAKE_BUILD_TYPE_LOWERCASE}.cmake)
    include(${CMAKE_SOURCE_DIR}/config/build_type/${CMAKE_BUILD_TYPE_LOWERCASE}.cmake)
endif()

# Load TF-M model specific default config
# Load IPC backend config if isolation level is explicitly specified to 2/3 or IPC backend is
# selected via build command line. Otherwise, load SFN backend config by default.
# If a pair of invalid settings are passed via command line, it will be captured later via config
# check.
# Also select IPC model by default for multi-core platform unless it has already selected SFN model
if((DEFINED TFM_ISOLATION_LEVEL AND TFM_ISOLATION_LEVEL GREATER 1) OR
    CONFIG_TFM_SPM_BACKEND STREQUAL "IPC" OR
    TFM_MULTI_CORE_TOPOLOGY)
    include(config/tfm_ipc_config_default.cmake)
else()
    #The default backend is SFN
    include(config/tfm_sfn_config_default.cmake)
endif()

# Load bl1 config
if(BL1 AND PLATFORM_DEFAULT_BL1)
    include(${CMAKE_SOURCE_DIR}/bl1/config/bl1_config_default.cmake)
endif()

# Load MCUboot specific default.cmake
if(NOT DEFINED BL2 OR BL2)
    include(${CMAKE_SOURCE_DIR}/bl2/ext/mcuboot/mcuboot_default_config.cmake)
endif()

# Include FWU partition configs.
include(config/tfm_fwu_config.cmake)

# Include coprocessor configs
include(config/cp_config_default.cmake)

# Load defaults, setting options not already set
include(config/config_base.cmake)

# Set secure log configs
# It also depends on regression test config.
include(config/tfm_secure_log.cmake)