alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
a9fa0d2505
esp-idf/components/ulp/cmake/CMakeLists.txt

201 lines
9.6 KiB
CMake
Raw Normal View History

tools: Increase the minimal supported CMake version to 3.16 This updates the minimal supported version of CMake to 3.16, which in turn enables us to use more CMake features and have a cleaner build system. This is the version that provides most new features and also the one we use in our latest docker image for CI.
2022-05-27 04:10:51 -04:00
cmake_minimum_required(VERSION 3.16)
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
tools: cmake: check tool supported version with idf_tools.py
2022-08-31 16:59:15 -04:00
include(${IDF_PATH}/tools/cmake/idf.cmake)
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
project(${ULP_APP_NAME} ASM C)
ulp: cmake: add the target early, use target_* commands everywhere Instead of collecting options in various variables, use CMake commands like target_sources and target_link_options.
2022-08-28 07:55:49 -04:00
add_executable(${ULP_APP_NAME})
ulp: Updated ULP CMakeLists.txt to output binary with .elf extension This commit updates the ULP CMakeLists.txt to output the ULP binary with a .elf extension. Currently the output file does not use any extension.
2023-02-17 04:22:34 -05:00
set(CMAKE_EXECUTABLE_SUFFIX ".elf")
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
option(ULP_COCPU_IS_RISCV "Use RISC-V based ULP" OFF)
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
option(ULP_COCPU_IS_LP_CORE "Use RISC-V based LP Core" OFF)
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
function(create_arg_file arguments output_file)
# Escape all spaces
list(TRANSFORM arguments REPLACE " " "\\\\ ")
# Create a single string with all args separated by space
list(JOIN arguments " " arguments)
# Write it into the response file
file(WRITE ${output_file} ${arguments})
endfunction()
ulp: refactor ulp component This commit refactors the ulp component. Files are now divided based on type of ulp, viz., fsm or risc-v. Files common to both are maintained in the ulp_common folder. This commit also adds menuconfig options for ULP within the ulp component instead of presenting target specific configuations for ulp.
2022-01-21 04:13:48 -05:00
message(STATUS "Building ULP app ${ULP_APP_NAME}")
make, cmake: display ulp assembler version
2018-11-27 06:31:46 -05:00
ulp: move the expected ULP-FSM toolchain version from .mk to CMake toolchain_ulp_version.mk is a remnant of the time when we had two build systems, and CMake had to read the expected version from a makefile.
2022-08-28 07:47:12 -04:00
# Check the supported assembler version
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
if(NOT (ULP_COCPU_IS_RISCV OR ULP_COCPU_IS_LP_CORE))
tools: cmake: check tool supported version with idf_tools.py
2022-08-31 16:59:15 -04:00
check_expected_tool_version("esp32ulp-elf" ${CMAKE_ASM_COMPILER})
ulp: move the expected ULP-FSM toolchain version from .mk to CMake toolchain_ulp_version.mk is a remnant of the time when we had two build systems, and CMake had to read the expected version from a makefile.
2022-08-28 07:47:12 -04:00
endif()
ulp: check assembler version
2018-08-31 05:32:24 -04:00
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
set(ULP_MAP_GEN ${PYTHON} ${IDF_PATH}/components/ulp/esp32ulp_mapgen.py)
ulp: Fix bug where ULP linker script not regenerated for new config ULP linker script relies on value of CONFIG_ESP32S2_ULP_COPROC_RESERVE_MEM, when this value changes in config then it should be regenerated.
2021-03-31 04:25:35 -04:00
get_filename_component(sdkconfig_dir ${SDKCONFIG_HEADER} DIRECTORY)
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
foreach(include ${COMPONENT_INCLUDES})
list(APPEND component_includes -I${include})
endforeach()
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
list(REMOVE_DUPLICATES component_includes)
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
list(APPEND ULP_PREPROCESSOR_ARGS ${component_includes})
components: update with build system changes
2019-05-09 22:53:08 -04:00
list(APPEND ULP_PREPROCESSOR_ARGS -I${COMPONENT_DIR})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
list(APPEND ULP_PREPROCESSOR_ARGS -I${sdkconfig_dir})
fix(rtc_memory): fix conflict between LP-ROM and RTC reserved
2024-04-02 23:55:06 -04:00
list(APPEND ULP_PREPROCESSOR_ARGS -I${IDF_PATH}/components/esp_system/ld)
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: cmake: add the target early, use target_* commands everywhere Instead of collecting options in various variables, use CMake commands like target_sources and target_link_options.
2022-08-28 07:55:49 -04:00
target_include_directories(${ULP_APP_NAME} PRIVATE ${COMPONENT_INCLUDES})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: cmake: simplify the dependency on the generated LD script * "dummy loop to force pre-processed linker file generation" seems to be unnecessary. It looks like the idea was copied from the dependency of ULP-FSM preprocessed source files on the LD script. * Can use add_dependencies instead of set_target_properties(...LINK_DEPENDS...) which is more readable * Use target_link_options instead of target_link_libraries, which is supported starting from CMake 3.13. Unlike target_link_libraries, it doesn't require manually quoting the pats.
2022-08-28 08:00:20 -04:00
# Pre-process the linker script
if(ULP_COCPU_IS_RISCV)
set(ULP_LD_TEMPLATE ${IDF_PATH}/components/ulp/ld/ulp_riscv.ld)
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
elseif(ULP_COCPU_IS_LP_CORE)
set(ULP_LD_TEMPLATE ${IDF_PATH}/components/ulp/ld/lp_core_riscv.ld)
ulp: cmake: simplify the dependency on the generated LD script * "dummy loop to force pre-processed linker file generation" seems to be unnecessary. It looks like the idea was copied from the dependency of ULP-FSM preprocessed source files on the LD script. * Can use add_dependencies instead of set_target_properties(...LINK_DEPENDS...) which is more readable * Use target_link_options instead of target_link_libraries, which is supported starting from CMake 3.13. Unlike target_link_libraries, it doesn't require manually quoting the pats.
2022-08-28 08:00:20 -04:00
else()
set(ULP_LD_TEMPLATE ${IDF_PATH}/components/ulp/ld/ulp_fsm.ld)
endif()
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
get_filename_component(ULP_LD_SCRIPT ${ULP_LD_TEMPLATE} NAME)
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
# Put all arguments to the list
set(preprocessor_args -D__ASSEMBLER__ -E -P -xc -o ${ULP_LD_SCRIPT} ${ULP_PREPROCESSOR_ARGS} ${ULP_LD_TEMPLATE})
set(compiler_arguments_file ${CMAKE_CURRENT_BINARY_DIR}/${ULP_LD_SCRIPT}_args.txt)
create_arg_file("${preprocessor_args}" "${compiler_arguments_file}")
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
add_custom_command(OUTPUT ${ULP_LD_SCRIPT}
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
COMMAND ${CMAKE_C_COMPILER} @${compiler_arguments_file}
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
ulp: cmake: simplify the dependency on the generated LD script * "dummy loop to force pre-processed linker file generation" seems to be unnecessary. It looks like the idea was copied from the dependency of ULP-FSM preprocessed source files on the LD script. * Can use add_dependencies instead of set_target_properties(...LINK_DEPENDS...) which is more readable * Use target_link_options instead of target_link_libraries, which is supported starting from CMake 3.13. Unlike target_link_libraries, it doesn't require manually quoting the pats.
2022-08-28 08:00:20 -04:00
MAIN_DEPENDENCY ${ULP_LD_TEMPLATE}
DEPENDS ${SDKCONFIG_HEADER}
COMMENT "Generating ${ULP_LD_SCRIPT} linker script..."
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
VERBATIM)
ulp: cmake: simplify the dependency on the generated LD script * "dummy loop to force pre-processed linker file generation" seems to be unnecessary. It looks like the idea was copied from the dependency of ULP-FSM preprocessed source files on the LD script. * Can use add_dependencies instead of set_target_properties(...LINK_DEPENDS...) which is more readable * Use target_link_options instead of target_link_libraries, which is supported starting from CMake 3.13. Unlike target_link_libraries, it doesn't require manually quoting the pats.
2022-08-28 08:00:20 -04:00
add_custom_target(ld_script DEPENDS ${ULP_LD_SCRIPT})
add_dependencies(${ULP_APP_NAME} ld_script)
target_link_options(${ULP_APP_NAME} PRIVATE SHELL:-T ${CMAKE_CURRENT_BINARY_DIR}/${ULP_LD_SCRIPT})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
fix: bypass Manually-specified variables were not used by the project warning the variable "IDF_TARGET" is only used under a if clause "if(ULP_C0CPU_IS_RISCV)". while building a non-riscv target, there will be a cmake warning: CMake Warning: Manually-specified variables were not used by the project: IDF_TARGET
2022-07-12 23:11:19 -04:00
# To avoid warning "Manually-specified variables were not used by the project"
set(bypassWarning "${IDF_TARGET}")
feat(lp-core): Added ability to print from LP ROM on the LP core This commit adds the ability to use LP ROM functions from the LP core. This allows the LP core code to utilize standard functions such as those for printing from the LP ROM and therefore help reduce the code size on the LP core.
2024-03-11 07:15:09 -04:00
set(bypassWarning "${CONFIG_ESP_ROM_HAS_LP_ROM}")
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
if(ULP_COCPU_IS_RISCV)
#risc-v ulp uses extra files for building:
Whitespace: Automated whitespace fixes (large commit) Apply the pre-commit hook whitespace fixes to all files in the repo. (Line endings, blank lines at end of file, trailing whitespace)
2020-11-10 02:40:01 -05:00
list(APPEND ULP_S_SOURCES
feat(ulp-riscv): Added interrupt vector handling for ULP RISC-V This commit adds interrupt vector processing for the ULP RISC-V co-processor.
2023-12-08 08:09:39 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_vectors.S"
ulp-riscv: add support for using ADC as well as an example show-casing it.
2022-02-28 05:12:28 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/start.S"
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_adc.c"
ulp-riscv: added lock API to provide mutual exclusion when sharing variables between the main CPU and the ULP.
2022-08-03 01:59:44 -04:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_lock.c"
Add ULP-RISCV print and bitbanged UART tx API Add example to demonstrate the use of this API.
2022-07-25 02:04:08 -04:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_uart.c"
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_print.c"
ulp: Added support for RTC I2C driver for ULP RISC-V on esp32s2 and esp32s3 This commit adds support for using the RTC I2C peripheral on the ULP RISC-V core for esp32s2 and esp32s3. It also adds an example to demonstrate the usage of the RTC I2C peripheral. This commit also modifies the rtc_i2c register structure files to enable the use of bitfields in the ULP RISC-V RTC I2C driver.
2022-08-09 09:46:14 -04:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_i2c.c"
ulp-riscv-touch: Added support for the touch sensor on ULP RISC-V This commit adds a driver for reading the touch sensor from the ULP RISC-V core during sleep. The commit also adds an example to demonstrate this feature. Closes https://github.com/espressif/esp-idf/issues/10480
2023-05-19 09:34:44 -04:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_utils.c"
feat(ulp-riscv): Added interrupt vector handling for ULP RISC-V This commit adds interrupt vector processing for the ULP RISC-V co-processor.
2023-12-08 08:09:39 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_touch.c"
feat(ulp-riscv): Added support for RTC IO interrupts for ULP RISC-V This commit adds a feature to register RTC IO interrupt handlers for the ULP RISC-V co-processor.
2023-12-14 07:26:00 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_gpio.c"
feat(ulp-riscv): Added interrupt vector handling for ULP RISC-V This commit adds interrupt vector processing for the ULP RISC-V co-processor.
2023-12-08 08:09:39 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/ulp_riscv_interrupt.c")
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
ulp: cmake: add the target early, use target_* commands everywhere Instead of collecting options in various variables, use CMake commands like target_sources and target_link_options.
2022-08-28 07:55:49 -04:00
target_link_options(${ULP_APP_NAME} PRIVATE "-nostartfiles")
target_link_options(${ULP_APP_NAME} PRIVATE -Wl,--gc-sections)
target_link_options(${ULP_APP_NAME} PRIVATE -Wl,-Map=${CMAKE_CURRENT_BINARY_DIR}/${ULP_APP_NAME}.map)
target_sources(${ULP_APP_NAME} PRIVATE ${ULP_S_SOURCES})
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
#Makes the csr utillies for riscv visible:
ulp-riscv: added lock API to provide mutual exclusion when sharing variables between the main CPU and the ULP.
2022-08-03 01:59:44 -04:00
target_include_directories(${ULP_APP_NAME} PRIVATE "${IDF_PATH}/components/ulp/ulp_riscv/ulp_core/include"
feat(ulp-riscv): Added interrupt vector handling for ULP RISC-V This commit adds interrupt vector processing for the ULP RISC-V co-processor.
2023-12-08 08:09:39 -05:00
"${IDF_PATH}/components/ulp/ulp_riscv/shared/include"
"${IDF_PATH}/components/riscv/include")
ulp: fix typo in peripherals ld file names
2022-08-28 08:13:15 -04:00
target_link_options(${ULP_APP_NAME} PRIVATE SHELL:-T ${IDF_PATH}/components/ulp/ld/${IDF_TARGET}.peripherals.ld)
tools: cmake: ignore linker RWX segment warnings
2022-10-10 10:16:45 -04:00
target_link_options(${ULP_APP_NAME} PRIVATE "-Wl,--no-warn-rwx-segments")
ulp-riscv: add support for using ADC as well as an example show-casing it.
2022-02-28 05:12:28 -05:00
target_compile_definitions(${ULP_APP_NAME} PRIVATE IS_ULP_COCPU)
fix(ulp_riscv): Fixed the header inclusion dependency for ulp_riscv_register_ops.h There are redefinition compilation warnings for the register operation macros when a ULP program was compiled which included soc.h before ulp_riscv_register_ops.h. This commit fixes the issues by delegating the exclusion macro to the CMakeLists.txt file. Closes: https://github.com/espressif/esp-idf/issues/12116
2023-08-28 05:39:48 -04:00
target_compile_definitions(${ULP_APP_NAME} PRIVATE ULP_RISCV_REGISTER_OPS)
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
elseif(ULP_COCPU_IS_LP_CORE)
list(APPEND ULP_S_SOURCES
"${IDF_PATH}/components/ulp/lp_core/lp_core/start.S"
ulp: added sleep support for lp core Added support for running LP core while hp core sleeps, as well as waking up the hp core.
2023-03-09 01:14:09 -05:00
"${IDF_PATH}/components/ulp/lp_core/lp_core/vector.S"
ulp: add support for using lp timer with lp core on C6
2023-04-26 01:58:19 -04:00
"${IDF_PATH}/components/ulp/lp_core/shared/ulp_lp_core_memory_shared.c"
"${IDF_PATH}/components/ulp/lp_core/shared/ulp_lp_core_lp_timer_shared.c"
ulp: added sleep support for lp core Added support for running LP core while hp core sleeps, as well as waking up the hp core.
2023-03-09 01:14:09 -05:00
"${IDF_PATH}/components/ulp/lp_core/lp_core/lp_core_startup.c"
lp-i2c: Added support for LP I2C peripheral to LP core This commit adds support for the LP I2C peripheral driver to be used by the LP core. An example is also added to demonstrate the usage of the LP I2C peripheral from the LP core.
2023-03-20 11:08:38 -04:00
"${IDF_PATH}/components/ulp/lp_core/lp_core/lp_core_utils.c"
feat(ulp/lp_core): Added basic support for building and running a LP-Core app on ESP32P4
2023-11-02 04:34:40 -04:00
lp-core-uart: Added LP UART support for LP core This commit adds a UART driver for the LP core to interact with the LP UART. The commit also adds an example to demonstrate the usage of the LP UART driver.
2023-05-22 08:48:15 -04:00
"${IDF_PATH}/components/hal/uart_hal_iram.c"
"${IDF_PATH}/components/hal/uart_hal.c"
lp-core-uart: Added support for printf to the LP core This commit adds a minimal logging driver for the LP core. The logging driver provides a printf function which is built on top of the LP UART driver. The commit also adds an example to demonstrate how to use print statements in an LP core program.
2023-05-30 11:42:19 -04:00
"${IDF_PATH}/components/ulp/lp_core/lp_core/lp_core_uart.c"
feat(ulp/lp_core): Added basic support for building and running a LP-Core app on ESP32P4
2023-11-02 04:34:40 -04:00
"${IDF_PATH}/components/ulp/lp_core/lp_core/lp_core_print.c"
"${IDF_PATH}/components/ulp/lp_core/lp_core/lp_core_i2c.c")
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
target_link_options(${ULP_APP_NAME} PRIVATE "-nostartfiles")
target_link_options(${ULP_APP_NAME} PRIVATE "-Wl,--no-warn-rwx-segments")
target_link_options(${ULP_APP_NAME} PRIVATE -Wl,--gc-sections)
target_link_options(${ULP_APP_NAME} PRIVATE -Wl,-Map=${CMAKE_CURRENT_BINARY_DIR}/${ULP_APP_NAME}.map)
feat(ulp): add basic support for running lp core on C5
2024-03-08 01:22:07 -05:00
if(${IDF_TARGET} STREQUAL "esp32c5")
set(target_folder "esp32c5/mp")
else()
set(target_folder ${IDF_TARGET})
endif()
ulp: add support for using lp timer with lp core on C6
2023-04-26 01:58:19 -04:00
target_link_options(${ULP_APP_NAME}
feat(ulp): add basic support for running lp core on C5
2024-03-08 01:22:07 -05:00
PRIVATE SHELL:-T ${IDF_PATH}/components/soc/${target_folder}/ld/${IDF_TARGET}.peripherals.ld)
feat(ulp/lp_core): Added basic support for building and running a LP-Core app on ESP32P4
2023-11-02 04:34:40 -04:00
if(CONFIG_ESP_ROM_HAS_LP_ROM)
target_link_options(${ULP_APP_NAME}
PRIVATE SHELL:-T ${IDF_PATH}/components/esp_rom/${IDF_TARGET}/ld/${IDF_TARGET}lp.rom.ld)
target_link_options(${ULP_APP_NAME}
PRIVATE SHELL:-T ${IDF_PATH}/components/esp_rom/${IDF_TARGET}/ld/${IDF_TARGET}lp.rom.newlib.ld)
target_link_options(${ULP_APP_NAME}
PRIVATE SHELL:-T ${IDF_PATH}/components/esp_rom/${IDF_TARGET}/ld/${IDF_TARGET}lp.rom.version.ld)
endif()
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
target_sources(${ULP_APP_NAME} PRIVATE ${ULP_S_SOURCES})
ulp: add support for using lp timer with lp core on C6
2023-04-26 01:58:19 -04:00
target_include_directories(${ULP_APP_NAME} PRIVATE "${IDF_PATH}/components/ulp/lp_core/lp_core/include"
"${IDF_PATH}/components/ulp/lp_core/shared/include")
lp-core-uart: Added LP UART support for LP core This commit adds a UART driver for the LP core to interact with the LP UART. The commit also adds an example to demonstrate the usage of the LP UART driver.
2023-05-22 08:48:15 -04:00
target_compile_definitions(${ULP_APP_NAME} PRIVATE IS_ULP_COCPU)
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
else()
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
foreach(ulp_s_source ${ULP_S_SOURCES})
get_filename_component(ulp_ps_source ${ulp_s_source} NAME_WE)
set(ulp_ps_output ${CMAKE_CURRENT_BINARY_DIR}/${ulp_ps_source}.ulp.S)
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
# Put all arguments to the list
set(preprocessor_args -D__ASSEMBLER__ -E -P -xc -o ${ulp_ps_output} ${ULP_PREPROCESSOR_ARGS} ${ulp_s_source})
set(compiler_arguments_file ${CMAKE_CURRENT_BINARY_DIR}/${ulp_ps_source}_args.txt)
create_arg_file("${preprocessor_args}" "${compiler_arguments_file}")
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
# Generate preprocessed assembly files.
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
add_custom_command(OUTPUT ${ulp_ps_output}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
fix(system): fix idf.py build ulp examples containing spaces in path on Win
2024-04-05 04:27:51 -04:00
COMMAND ${CMAKE_C_COMPILER} @${compiler_arguments_file}
ulp: cmake: simplify the dependency on the generated LD script * "dummy loop to force pre-processed linker file generation" seems to be unnecessary. It looks like the idea was copied from the dependency of ULP-FSM preprocessed source files on the LD script. * Can use add_dependencies instead of set_target_properties(...LINK_DEPENDS...) which is more readable * Use target_link_options instead of target_link_libraries, which is supported starting from CMake 3.13. Unlike target_link_libraries, it doesn't require manually quoting the pats.
2022-08-28 08:00:20 -04:00
DEPENDS ${ulp_s_source}
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
VERBATIM)
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
# During assembly file compilation, output listing files as well.
set_source_files_properties(${ulp_ps_output}
PROPERTIES COMPILE_FLAGS
"-al=${CMAKE_CURRENT_BINARY_DIR}/${ulp_ps_source}.lst")
list(APPEND ULP_PS_SOURCES ${ulp_ps_output})
endforeach()
Whitespace: Automated whitespace fixes (large commit) Apply the pre-commit hook whitespace fixes to all files in the repo. (Line endings, blank lines at end of file, trailing whitespace)
2020-11-10 02:40:01 -05:00
ulp: cmake: add the target early, use target_* commands everywhere Instead of collecting options in various variables, use CMake commands like target_sources and target_link_options.
2022-08-28 07:55:49 -04:00
target_link_options(${ULP_APP_NAME} PRIVATE -Map=${CMAKE_CURRENT_BINARY_DIR}/${ULP_APP_NAME}.map)
target_sources(${ULP_APP_NAME} PRIVATE ${ULP_PS_SOURCES})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: added support to building code for riscv ULP coprocessor
2020-04-17 15:34:56 -04:00
endif()
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
ulp: added basic support for building and running a binary in the lp core
2023-02-27 04:03:42 -05:00
if(ULP_COCPU_IS_LP_CORE)
set(ULP_BASE_ADDR "0x0")
else()
set(ULP_BASE_ADDR "0x50000000")
endif()
ulp: esp32ulp_mapgen: remove the special case for RISC-V, cleanup There are multiple changes in this commit: 1. Unify the RISC-V and ULP-FSM code paths in esp32ulp_mapgen.py. It seems that these were originally introduced because `nm` output for the RISC-V case contained symbol sizes, while for the ULP-FSM no symbol sizes were reported. This makes sense, because the ULP-FSM object files are produced from assembly source, symbol sizes have to be added manually using the .size directive. In the case of RISC-V, the object files are built from C sources and the sizes are automatically added by the compiler. Now 'posix' output format is used for both RISC-V and ULP-FSM. 2. Move BASE_ADDR out of esp32ulp_mapgen.py. This now has to be passed from CMake, which should make it easier to modify if a new chip with a different RTC RAM base address is added. 3. Add C++ guards to the generated header file. 4. Switch from optparse to argparse for similarity with other IDF tools. 5. Add type annotations.
2022-08-28 08:11:46 -04:00
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
# Dump the list of global symbols in a convenient format
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
add_custom_command(OUTPUT ${ULP_APP_NAME}.sym
ulp: esp32ulp_mapgen: remove the special case for RISC-V, cleanup There are multiple changes in this commit: 1. Unify the RISC-V and ULP-FSM code paths in esp32ulp_mapgen.py. It seems that these were originally introduced because `nm` output for the RISC-V case contained symbol sizes, while for the ULP-FSM no symbol sizes were reported. This makes sense, because the ULP-FSM object files are produced from assembly source, symbol sizes have to be added manually using the .size directive. In the case of RISC-V, the object files are built from C sources and the sizes are automatically added by the compiler. Now 'posix' output format is used for both RISC-V and ULP-FSM. 2. Move BASE_ADDR out of esp32ulp_mapgen.py. This now has to be passed from CMake, which should make it easier to modify if a new chip with a different RTC RAM base address is added. 3. Add C++ guards to the generated header file. 4. Switch from optparse to argparse for similarity with other IDF tools. 5. Add type annotations.
2022-08-28 08:11:46 -04:00
COMMAND ${CMAKE_NM} -f posix -g $<TARGET_FILE:${ULP_APP_NAME}> > ${ULP_APP_NAME}.sym
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
DEPENDS ${ULP_APP_NAME}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
# Dump the binary for inclusion into the project
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
add_custom_command(OUTPUT ${ULP_APP_NAME}.bin
COMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${ULP_APP_NAME}> ${ULP_APP_NAME}.bin
DEPENDS ${ULP_APP_NAME}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
add_custom_command(OUTPUT ${ULP_APP_NAME}.ld ${ULP_APP_NAME}.h
ulp: esp32ulp_mapgen: remove the special case for RISC-V, cleanup There are multiple changes in this commit: 1. Unify the RISC-V and ULP-FSM code paths in esp32ulp_mapgen.py. It seems that these were originally introduced because `nm` output for the RISC-V case contained symbol sizes, while for the ULP-FSM no symbol sizes were reported. This makes sense, because the ULP-FSM object files are produced from assembly source, symbol sizes have to be added manually using the .size directive. In the case of RISC-V, the object files are built from C sources and the sizes are automatically added by the compiler. Now 'posix' output format is used for both RISC-V and ULP-FSM. 2. Move BASE_ADDR out of esp32ulp_mapgen.py. This now has to be passed from CMake, which should make it easier to modify if a new chip with a different RTC RAM base address is added. 3. Add C++ guards to the generated header file. 4. Switch from optparse to argparse for similarity with other IDF tools. 5. Add type annotations.
2022-08-28 08:11:46 -04:00
COMMAND ${ULP_MAP_GEN} -s ${ULP_APP_NAME}.sym -o ${ULP_APP_NAME} --base ${ULP_BASE_ADDR}
cmake: Apply cmakelint fixes
2020-11-10 01:51:08 -05:00
DEPENDS ${ULP_APP_NAME}.sym
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
# Building the component separately from the project should result in
# ULP files being built.
add_custom_target(build
DEPENDS ${ULP_APP_NAME} ${ULP_APP_NAME}.bin ${ULP_APP_NAME}.sym
ulp: check assembler version
2018-08-31 05:32:24 -04:00
${CMAKE_CURRENT_BINARY_DIR}/${ULP_APP_NAME}.ld
cmake: add ulp components build support
2018-09-13 02:54:59 -04:00
${CMAKE_CURRENT_BINARY_DIR}/${ULP_APP_NAME}.h
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
Reference in New Issue Copy Permalink