gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2025-03-04 10:48:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

closer, tasks populating targets

Browse Source
This commit is contained in:
Jack Humbert 2023-04-04 12:07:58 -04:00
parent 6468360ff1
commit 531c37b256
20 changed files with 354 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
.vscode/tasks.json vendored
View File

@ -23,15 +23,13 @@
"label": "Configure CMake",
"type": "cmake",
"command": "configure"
// "command": "${command:cmake.configure}",
// "problemMatcher": [],
},
{
"label": "Build",
"problemMatcher": [
{
"base": "$gcc",
"fileLocation": ["relative", "${workspaceRoot}/build"]
"fileLocation": ["relative", "${workspaceFolder}/build"]
},
],
"options": {
@ -42,57 +40,36 @@
"type": "cmake",
"command": "build",
"targets":[
"${input:keyboard_safe}"
"${input:keyboard_target}"
],
"group": {
"kind": "build",
"isDefault": true
},
// "type": "shell",
// "command": "cmake --build build --target ${input:keyboard_safe}",
// "problemMatcher": [],
// "group": {
// "kind": "build",
// "isDefault": true
// }
// "type": "cmake",
// "command": "build",
// "targets":[
// "${input:keyboard_safe}"
// ]
},
{
"label": "Rebuild",
// "type": "process",
// "command": "cmake",
// "args": [
// "--build",
// "build",
// "--target",
// "${input:keyboard_safe}",
// "--clean-first"
// ],
"problemMatcher": [
{
"base": "$gcc",
"fileLocation": ["relative", "${workspaceRoot}/build"]
},
],
"options": {
"environment": {
"CLICOLOR_FORCE": "1"
}
},
"type": "cmake",
"command": "cleanRebuild",
"targets":[
"${input:keyboard_safe}"
],
"group": {
"kind": "build",
"isDefault": true
},
}
// {
// "label": "Rebuild",
// "problemMatcher": [
// {
// "base": "$gcc",
// "fileLocation": ["relative", "${workspaceFolder}/build"]
// },
// ],
// "options": {
// "environment": {
// "CLICOLOR_FORCE": "1"
// }
// },
// "type": "cmake",
// "command": "cleanRebuild",
// "targets":[
// "${input:keyboard_target}"
// ],
// "group": {
// "kind": "build",
// "isDefault": true
// },
// }
],
"inputs": [
{
@ -105,33 +82,14 @@
]
},
{
"id": "keyboard_safe",
"description": "Keyboard:",
"type": "pickString",
"options":[
"planck_rev5_default",
"olkb_planck_rev3_default"
]
},
// {
// "type": "command",
// "id": "keyboard",
// "command": "extension.commandvariable.pickStringRemember",
// "args": {
// "description": "select an option :",
// "options": [
// ["always 1", "5000"],
// ["always 2", "5100"]
// ],
// "default": "",
// "fileName": "${workspaceFolder}/data/keyboards.json",
// "pattern": {
// "regexp": "^\\s*(?!#)([^=]+?)\\s*=\\s*(?:(\\{.+\\})|(.+))$",
// "label": "$1",
// "json": "$2",
// "value": "$3"
// }
// }
// }
"id": "keyboard_target",
"type": "command",
"command": "shellCommand.execute",
"args": {
"command": "type build\\targets",
"description": "Target:",
"fieldSeparator": "|"
},
}
]
}

154
CMakeLists.txt
View File

@ -3,11 +3,27 @@ cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
include(UpdateSubmodule)
include(ResolveKeyboard)
include(ValidateJSON)
set(QMK_KEYBOARDS_FOLDER "${CMAKE_SOURCE_DIR}/keyboards")
# early declaration of macro defined in toolchain
# macro(add_qmk_executable _)
# endmacro(add_qmk_executable)
function (_get_all_cmake_targets out_var current_dir)
get_property(targets DIRECTORY ${current_dir} PROPERTY BUILDSYSTEM_TARGETS)
get_property(subdirs DIRECTORY ${current_dir} PROPERTY SUBDIRECTORIES)
foreach(subdir ${subdirs})
_get_all_cmake_targets(subdir_targets ${subdir})
list(APPEND targets ${subdir_targets})
endforeach()
set(${out_var} ${targets} PARENT_SCOPE)
endfunction()
if(NOT DEFINED QMK_KEYBOARD)
# configure step - populate targets
@ -16,118 +32,30 @@ project(qmk_firmware)
add_subdirectory(keyboards)
# Run at end of top-level CMakeLists
# _get_all_cmake_targets(all_targets ${CMAKE_SOURCE_DIR})
# message(STATUS "All: ${all_targets}")
# list(JOIN all_targets "\n" TARGET_FILE)
# file(WRITE "${CMAKE_SOURCE_DIR}/build/targets" ${TARGET_FILE})
else()
# build step
include(ResolveKeyboard)
resolve_keyboard(${QMK_KEYBOARD_FOLDER} QMK_KEYBOARD_FOLDER_ABS)
set(TEMP_PATH ${QMK_KEYBOARD_FOLDER})
cmake_path(IS_RELATIVE TEMP_PATH IS_KEYBOARD_FOLDER_RELATIVE)
if(${IS_KEYBOARD_FOLDER_RELATIVE} AND NOT EXISTS ${CMAKE_SOURCE_DIR}/keyboards/${QMK_KEYBOARD_FOLDER})
set(IS_KEYBOARD_FOLDER_RELATIVE FALSE)
endif()
if(NOT DEFINED QMK_KEYMAP_FOLDER)
set(QMK_KEYMAP_FOLDER "default")
endif()
set(TEMP_PATH ${QMK_KEYMAP_FOLDER})
cmake_path(IS_RELATIVE TEMP_PATH IS_KEYMAP_FOLDER_RELATIVE)
resolve_keyboard(${QMK_KEYBOARD_FOLDER} QMK_KEYBOARD_FOLDER_ABS)
cmake_path(IS_PREFIX QMK_KEYBOARDS_FOLDER "${QMK_KEYBOARD_FOLDER_ABS}" IS_KEYBOARDS_FOLDER)
resolve_config_h(${QMK_KEYBOARD_FOLDER_ABS} QMK_KEYBOARD_CONFIG_H)
resolve_keyboard_h(${QMK_KEYBOARD_FOLDER_ABS} QMK_KEYBOARD_H)
resolve_keymap_c(${QMK_KEYBOARD_FOLDER_ABS} ${QMK_KEYMAP_FOLDER} QMK_KEYMAP_C)
if(${IS_KEYBOARD_FOLDER_RELATIVE})
set(QMK_KEYBOARD_CURRENT_FOLDER ${QMK_KEYBOARD_FOLDER})
set(QMK_KEYBOARD_FOLDERS)
set(QMK_KEYBOARD_FOLDER_PARTS)
while(NOT ${QMK_KEYBOARD_CURRENT_FOLDER} STREQUAL "")
get_filename_component(QMK_KEYBOARD_CURRENT_PART ${QMK_KEYBOARD_CURRENT_FOLDER} NAME)
list(PREPEND QMK_KEYBOARD_FOLDER_PARTS ${QMK_KEYBOARD_CURRENT_PART})
list(PREPEND QMK_KEYBOARD_FOLDERS ${QMK_KEYBOARD_CURRENT_FOLDER})
get_filename_component(QMK_KEYBOARD_CURRENT_FOLDER ${QMK_KEYBOARD_CURRENT_FOLDER} DIRECTORY)
endwhile()
message(STATUS "config.h: ${QMK_KEYBOARD_CONFIG_H}")
message(STATUS "keyboard.h: ${QMK_KEYBOARD_H}")
message(STATUS "Keymap.c: ${QMK_KEYMAP_C}")
foreach(FOLDER ${QMK_KEYBOARD_FOLDERS})
include_directories(${CMAKE_SOURCE_DIR}/keyboards/${FOLDER})
# assuming every keyboard has a config at some level
if(EXISTS ${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/config.h)
list(APPEND QMK_KEYBOARD_CONFIG_HS "${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/config.h")
endif()
if(${IS_KEYMAP_FOLDER_RELATIVE})
# assuming every keyboard has a default/keymap.c at some level
if(EXISTS ${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/keymaps/${QMK_KEYMAP_FOLDER}/keymap.c)
list(APPEND QMK_KEYBOARD_KEYMAPS "${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/keymaps/${QMK_KEYMAP_FOLDER}/keymap.c")
elseif(EXISTS ${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/keymap.c)
list(APPEND QMK_KEYBOARD_KEYMAPS "${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/keymap.c")
endif()
endif()
get_filename_component(LAST_PART ${FOLDER} NAME)
# assuming every keyboard has a header.h at some level
if(EXISTS ${CMAKE_SOURCE_DIR}/keyboards/${FOLDER}/${LAST_PART}.h)
# use just the filename, since the folder is already in our include path (maybe it should only be the base keyboard folder?)
list(APPEND QMK_KEYBOARD_HEADERS "${LAST_PART}.h")
endif()
# not sure if merging is needed, since info.json is required per level? iirc
# if(EXISTS keyboards/${FOLDER}/info.json)
# file(READ keyboards/${FOLDER}/info.json QMK_KEYBOARD_INFO_JSON_STRING)
# string(JSON KEYBOARD_NAME GET ${QMK_KEYBOARD_INFO_JSON_STRING} keyboard_name)
# string(JSON MANUFACTURER GET ${QMK_KEYBOARD_INFO_JSON_STRING} manufacturer)
# string(JSON QMK_MCU GET ${QMK_KEYBOARD_INFO_JSON_STRING} processor)
# string(JSON VENDOR_ID GET ${QMK_KEYBOARD_INFO_JSON_STRING} usb vid)
# string(JSON PRODUCT_ID GET ${QMK_KEYBOARD_INFO_JSON_STRING} usb pid)
# string(JSON DEVICE_VER GET ${QMK_KEYBOARD_INFO_JSON_STRING} usb device_version)
# endif()
endforeach()
if(${IS_KEYMAP_FOLDER_RELATIVE})
if(NOT DEFINED QMK_KEYBOARD_KEYMAPS)
message(FATAL_ERROR "Keymap not found")
endif()
list(GET QMK_KEYBOARD_KEYMAPS 0 QMK_KEYBOARD_KEYMAP)
else()
if(EXISTS "${QMK_KEYMAP_FOLDER}/keymap.c")
set(QMK_KEYBOARD_KEYMAP "${QMK_KEYMAP_FOLEDR}/keymap.c")
else()
message(FATAL_ERROR "Could not find keymap.c in keymap folder")
endif()
endif()
if(NOT DEFINED QMK_KEYBOARD_HEADERS)
message(FATAL_ERROR "Header not found")
endif()
list(GET QMK_KEYBOARD_HEADERS -1 QMK_KEYBOARD_HEADER)
else(${IS_KEYBOARD_FOLDER_RELATIVE})
include_directories(${QMK_KEYBOARD_FOLDER_ABS})
if(EXISTS ${QMK_KEYBOARD_FOLDER_ABS}/config.h)
list(APPEND QMK_KEYBOARD_CONFIG_HS "${QMK_KEYBOARD_FOLDER_ABS}/config.h")
endif()
if(${IS_KEYMAP_FOLDER_RELATIVE})
if(EXISTS "${QMK_KEYBOARD_FOLDER_ABS}/keymaps/${QMK_KEYMAP_FOLDER}/keymap.c")
set(QMK_KEYBOARD_KEYMAP "${QMK_KEYBOARD_FOLDER_ABS}/keymaps/${QMK_KEYMAP_FOLDER}/keymap.c")
elseif(EXISTS "${QMK_KEYBOARD_FOLDER_ABS}/keymap.c")
set(QMK_KEYBOARD_KEYMAP "${QMK_KEYBOARD_FOLDER_ABS}/keymap.c")
else()
message(FATAL_ERROR "Could not find keymap in keymap folder '${QMK_KEYMAP_FOLDER}'")
endif()
else()
if(EXISTS "${QMK_KEYMAP_FOLDER}/keymap.c")
set(QMK_KEYBOARD_KEYMAP "{QMK_KEYMAP_FOLDER}/keymap.c")
else()
message(FATAL_ERROR "Could not find keymap in keymap path '${QMK_KEYMAP_FOLDER}'")
endif()
endif()
if(NOT DEFINED QMK_KEYBOARD_HEADER)
get_filename_component(LAST_PART ${QMK_KEYBOARD_FOLDER_ABS} NAME)
if(EXISTS "${QMK_KEYBOARD_FOLDER_ABS}/${LAST_PART}.h")
set(QMK_KEYBOARD_HEADER "${LAST_PART}.h")
elseif(EXISTS "${QMK_KEYBOARD_FOLDER_ABS}/keyboard.h")
set(QMK_KEYBOARD_HEADER "keyboard.h")
endif()
endif()
endif()
include(ValidateJSON)
validate_json(${QMK_KEYBOARD_FOLDER_ABS}/info.json keyboard QMK_KEYBOARD_INFO_JSON_STRING)
string(JSON KEYBOARD_NAME GET ${QMK_KEYBOARD_INFO_JSON_STRING} keyboard_name)
@ -139,7 +67,7 @@ string(JSON PRODUCT_ID GET ${QMK_KEYBOARD_INFO_JSON_STRING} usb pid)
string(JSON DEVICE_VER GET ${QMK_KEYBOARD_INFO_JSON_STRING} usb device_version)
project(${QMK_KEYBOARD}
LANGUAGES C CXX ASM
LANGUAGES C CXX ASM
HOMEPAGE_URL ${URL}
VERSION ${DEVICE_VER})
@ -150,12 +78,12 @@ set(VERSION_PATCH ${CMAKE_MATCH_3})
math(EXPR VERSION_C_EVAL "${VERSION_MAJOR} * 10000 + ${VERSION_MINOR} * 100 + ${VERSION_PATCH}" OUTPUT_FORMAT HEXADECIMAL)
add_compile_options(
-include ${QMK_KEYBOARD_CONFIG_HS}
-include ${QMK_KEYBOARD_CONFIG_H}
)
add_compile_definitions(
QMK_KEYBOARD_H="${QMK_KEYBOARD_HEADER}"
KEYMAP_C="${QMK_KEYBOARD_KEYMAP}"
QMK_KEYBOARD_H="${QMK_KEYBOARD_H}"
KEYMAP_C="${QMK_KEYMAP_C}"
MATRIX_ROWS=6
MATRIX_COLS=15
VENDOR_ID=${VENDOR_ID}
@ -165,13 +93,6 @@ add_compile_definitions(
PRODUCT="${KEYBOARD_NAME}"
)
add_subdirectory(quantum)
add_subdirectory(platforms)
add_subdirectory(tmk_core/protocol)
include(features/oled)
include(features/backlight)
if(EXISTS ${QMK_KEYBOARD_FOLDER_ABS}/CMakeLists.txt)
add_subdirectory(${QMK_KEYBOARD_FOLDER_ABS})
else()
@ -180,4 +101,11 @@ else()
add_qmk_executable(${QMK_KEYBOARD} ${KEYBOARD_SRC})
endif()
add_subdirectory(quantum)
add_subdirectory(platforms)
add_subdirectory(tmk_core/protocol)
include(features/oled)
include(features/backlight)
endif()

40
cmake/AddKeyboard.cmake
View File

@ -1,5 +1,6 @@
include(ResolveKeyboard)
include(ValidateJSON)
include(ResolveToolchain)
macro(add_keyboard KEYBOARD_FOLDER KEYMAP_FOLDER)
# not entirely sure why this is necessary
@ -41,51 +42,34 @@ macro(add_keyboard KEYBOARD_FOLDER KEYMAP_FOLDER)
validate_json(${KEYBOARD_FOLDER_ABS}/info.json keyboard JSON_STRING)
string(JSON PROCESSOR GET ${JSON_STRING} processor)
if(${PROCESSOR} MATCHES "^at.*")
set(PLATFORM "avr")
set(TOOLCHAIN "avr")
include(FindAVRToolchain)
find_avr_toolchain()
elseif(
${PROCESSOR} MATCHES "^STM.*" OR
${PROCESSOR} MATCHES "^WB32.*" OR
${PROCESSOR} MATCHES "^MK.*" OR
${PROCESSOR} MATCHES "RP2040" OR
${PROCESSOR} MATCHES "^GD32.*")
set(PLATFORM "chibios")
set(TOOLCHAIN "arm-none-eabi")
include(FindARMToolchain)
find_arm_toolchain()
endif()
if(NOT DEFINED PLATFORM)
message(FATAL_ERROR "Could not find platform for ${KEYBOARD_FOLDER}")
endif()
resolve_toolchain(${PROCESSOR} TOOLCHAIN)
string(JSON KEYBOARD_NAME GET ${JSON_STRING} keyboard_name)
if(${IS_KEYBOARD_FOLDER_RELATIVE})
string(MAKE_C_IDENTIFIER ${KEYBOARD_FOLDER} KEYBOARD_NAME)
string(MAKE_C_IDENTIFIER ${KEYBOARD_FOLDER} KEYBOARD_SLUG)
else()
string(JSON KEYBOARD_NAME GET ${JSON_STRING} keyboard_name)
string(MAKE_C_IDENTIFIER ${KEYBOARD_NAME} KEYBOARD_NAME)
string(MAKE_C_IDENTIFIER ${KEYBOARD_NAME} KEYBOARD_SLUG)
endif()
string(JSON MANUFACTURER GET ${JSON_STRING} manufacturer)
ExternalProject_Add(${KEYBOARD_NAME}_${KEYMAP_NAME}
ExternalProject_Add(${KEYBOARD_SLUG}_${KEYMAP_NAME}
SOURCE_DIR ${CMAKE_SOURCE_DIR}
PREFIX ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}
# PREFIX ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}
TMP_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/tmp
DOWNLOAD_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Download
BINARY_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Build
STAMP_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Stamp
LOG_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Log
INSTALL_DIR ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Install
INSTALL_COMMAND cmake -E echo "No install needed"
INSTALL_COMMAND ${CMAKE_COMMAND} -E echo "nothing to install" #copy ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Build/* ${CMAKE_SOURCE_DIR}/build/keyboards/${KEYBOARD_FOLDER}/Install/
# this seems to work well for all systems so far - not sure if it'd be useful to customize
CMAKE_GENERATOR "Unix Makefiles"
CMAKE_ARGS
-DCMAKE_TOOLCHAIN_FILE=${CMAKE_SOURCE_DIR}/cmake/toolchains/${TOOLCHAIN}.cmake
-DTOOLCHAIN_ROOT=${TOOLCHAIN_ROOT}
-DMAKE_ROOT=${MAKE_ROOT}
-DQMK_KEYBOARD=${KEYBOARD_NAME}
-DQMK_KEYBOARD=${KEYBOARD_SLUG}
-DQMK_KEYBOARD_FOLDER=${KEYBOARD_FOLDER}
-DQMK_KEYMAP_FOLDER=${KEYMAP_FOLDER}
)
file(APPEND "${CMAKE_SOURCE_DIR}/build/targets" "${KEYBOARD_SLUG}_${KEYMAP_NAME}|${KEYBOARD_NAME}|${MANUFACTURER}|${KEYBOARD_FOLDER}\n")
endmacro(add_keyboard)

58
cmake/FindARMToolchain.cmake
View File

@ -1,63 +1,15 @@
macro(find_gcc TRIPLE)
if(UNIX)
set(OS_SUFFIX "")
find_path(ARM_TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
elseif(WIN32)
set(OS_SUFFIX ".exe")
find_path(ARM_TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin"
"${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-10.3-2021.10/bin/"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin/"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
else(UNIX)
message(FATAL_ERROR "toolchain not supported on this OS")
endif(UNIX)
endmacro(find_gcc)
macro(find_arm_toolchain)
find_gcc(arm-none-eabi)
find_toolchain(arm-none-eabi TOOLCHAIN_ROOT MAKE_ROOT)
if(NOT ARM_TOOLCHAIN_ROOT)
if(NOT TOOLCHAIN_ROOT)
include(GetARMToolchain)
find_gcc(arm-none-eabi)
find_toolchain(arm-none-eabi TOOLCHAIN_ROOT MAKE_ROOT)
endif()
if(NOT ARM_TOOLCHAIN_ROOT)
if(NOT TOOLCHAIN_ROOT)
message(FATAL_ERROR "ARM Toolchain could not be found")
endif()
set(TOOLCHAIN_ROOT ${ARM_TOOLCHAIN_ROOT})
message(STATUS "ARM toolchain found: ${ARM_TOOLCHAIN_ROOT}")
message(STATUS "ARM toolchain found: ${TOOLCHAIN_ROOT}")
message(STATUS "Found make: ${MAKE_ROOT}")
endmacro()

57
cmake/FindAVRToolchain.cmake
View File

@ -1,62 +1,15 @@
macro(find_gcc TRIPLE)
if(UNIX)
set(OS_SUFFIX "")
find_path(AVR_TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
elseif(WIN32)
set(OS_SUFFIX ".exe")
find_path(AVR_TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin/"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
else(UNIX)
message(FATAL_ERROR "toolchain not supported on this OS")
endif(UNIX)
endmacro(find_gcc)
macro(find_avr_toolchain)
find_gcc(avr)
find_toolchain(avr TOOLCHAIN_ROOT MAKE_ROOT)
if(NOT AVR_TOOLCHAIN_ROOT)
if(NOT TOOLCHAIN_ROOT)
include(GetAVRToolchain)
find_gcc(avr)
find_toolchain(avr TOOLCHAIN_ROOT MAKE_ROOT)
endif()
if(NOT AVR_TOOLCHAIN_ROOT)
if(NOT TOOLCHAIN_ROOT)
message(FATAL_ERROR "AVR Toolchain could not be found")
endif()
set(TOOLCHAIN_ROOT ${AVR_TOOLCHAIN_ROOT})
message(STATUS "AVR toolchain found: ${AVR_TOOLCHAIN_ROOT}")
message(STATUS "AVR toolchain found: ${TOOLCHAIN_ROOT}")
message(STATUS "Found make: ${MAKE_ROOT}")
endmacro()

66
cmake/FindToolchain.cmake
View File

@ -1,66 +0,0 @@
macro(find_gcc TRIPLE)
if(UNIX)
set(OS_SUFFIX "")
find_path(TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
elseif(WIN32)
set(OS_SUFFIX ".exe")
find_path(TOOLCHAIN_ROOT
NAMES
${TRIPLE}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin"
"${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-10.3-2021.10/bin/"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
find_path(MAKE_ROOT
NAMES
make${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin/"
"C:/Users/Jack/Downloads/avr-gcc-12.1.0-x64-windows/bin/"
$ENV{AVR_ROOT}
)
else(UNIX)
message(FATAL_ERROR "toolchain not supported on this OS")
endif(UNIX)
endmacro(find_gcc)
macro(find_toolchain TRIPLE)
find_gcc(${TRIPLE})
if(NOT TOOLCHAIN_ROOT)
if("${TRIPLE}" STREQUAL "avr")
include(GetAVRToolchain)
else()
include(GetARMToolchain)
endif()
find_gcc(${TRIPLE})
endif()
if(NOT TOOLCHAIN_ROOT)
message(FATAL_ERROR "Toolchain could not be found")
endif()
message("Found toolchain for ${TRIPLE}: ${TOOLCHAIN_ROOT}")
message("Found make: ${MAKE_ROOT}")
endmacro()

7
cmake/Findlufa.cmake
View File

@ -19,5 +19,10 @@ add_library(lufa
${LUFA_ROOT_PATH}/Drivers/USB/Core/${ARCH}/Endpoint_${ARCH}.c
${LUFA_ROOT_PATH}/Drivers/USB/Core/${ARCH}/EndpointStream_${ARCH}.c
${LUFA_ROOT_PATH}/Drivers/USB/Core/DeviceStandardReq.c
${LUFA_PATH}/LUFA/Drivers/USB/USB.h
)
target_include_directories(lufa PUBLIC ${LUFA_PATH})
target_include_directories(lufa PUBLIC ${LUFA_PATH})
target_link_libraries(lufa ${QMK_TARGET})
target_link_libraries(lufa tmk_core_protocol)
target_link_libraries(lufa tmk_core_protocol_lufa)

74
cmake/ResolveKeyboard.cmake
View File

@ -39,4 +39,78 @@ function(resolve_keyboard KEYBOARD KEYBOAD_FOLDER_ABS_STR)
message(FATAL_ERROR "Couldn't find")
# set(${RESULT_STR} "NOTFOUND" PARENT_SCOPE)
endif()
endfunction()
function(resolve_config_h KEYBOARD_FOLDER_ABS CONFIG_H_STR)
if(${IS_KEYBOARDS_FOLDER})
file(RELATIVE_PATH RELATIVE_KEYBOARD_FOLDER ${QMK_KEYBOARDS_FOLDER} ${KEYBOARD_FOLDER_ABS})
# get the deepest config.h
while(NOT ${RELATIVE_KEYBOARD_FOLDER} STREQUAL "")
if(EXISTS "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/config.h")
set(${CONFIG_H_STR} "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/config.h" PARENT_SCOPE)
return()
endif()
get_filename_component(RELATIVE_KEYBOARD_FOLDER ${RELATIVE_KEYBOARD_FOLDER} DIRECTORY)
endwhile()
message(FATAL_ERROR "Could not find config.h in ${KEYBOARD_FOLDER_ABS}")
else()
if(EXISTS "${KEYBOARD_FOLDER_ABS}/config.h")
set(${CONFIG_H_STR} "${KEYBOARD_FOLDER_ABS}/config.h" PARENT_SCOPE)
else()
message(FATAL_ERROR "Could not find config.h in ${KEYBOARD_FOLDER_ABS}")
endif()
endif()
endfunction()
function(resolve_keyboard_h KEYBOARD_FOLDER_ABS KEYBOARD_H_STR)
if(${IS_KEYBOARDS_FOLDER})
file(RELATIVE_PATH RELATIVE_KEYBOARD_FOLDER ${QMK_KEYBOARDS_FOLDER} ${KEYBOARD_FOLDER_ABS})
# get the deepest header
while(NOT ${RELATIVE_KEYBOARD_FOLDER} STREQUAL "")
get_filename_component(LAST_PART ${RELATIVE_KEYBOARD_FOLDER} NAME)
if(EXISTS "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/${LAST_PART}.h")
set(${KEYBOARD_H_STR} "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/${LAST_PART}.h" PARENT_SCOPE)
return()
endif()
get_filename_component(RELATIVE_KEYBOARD_FOLDER ${RELATIVE_KEYBOARD_FOLDER} DIRECTORY)
endwhile()
message(FATAL_ERROR "Could not find *.h in ${KEYBOARD_FOLDER_ABS}")
else()
if(EXISTS "${KEYBOARD_FOLDER_ABS}/keyboard.h")
set(${KEYBOARD_H_STR} "${KEYBOARD_FOLDER_ABS}/keyboard.h" PARENT_SCOPE)
else()
message(FATAL_ERROR "Could not find keyboard.h in ${KEYBOARD_FOLDER_ABS}")
endif()
endif()
endfunction()
function(resolve_keymap_c KEYBOARD_FOLDER_ABS KEYMAP_FOLDER KEYMAP_C_STR)
if(IS_ABSOLUTE ${KEYMAP_FOLDER})
if(EXISTS "${KEYMAP_FOLDER}/keymap.c")
set(${KEYMAP_C_STR} "${KEYMAP_FOLDER}/keymap.c" PARENT_SCOPE)
else()
message(FATAL_ERROR "Could not find keymap.c in ${KEYMAP_FOLDER}")
endif()
else()
if(${IS_KEYBOARDS_FOLDER})
file(RELATIVE_PATH RELATIVE_KEYBOARD_FOLDER ${QMK_KEYBOARDS_FOLDER} ${KEYBOARD_FOLDER_ABS})
# get the deepest keymap.c
while(NOT ${RELATIVE_KEYBOARD_FOLDER} STREQUAL "")
if(EXISTS "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/keymaps/${KEYMAP_FOLDER}/keymap.c")
set(${KEYMAP_C_STR} "${QMK_KEYBOARDS_FOLDER}/${RELATIVE_KEYBOARD_FOLDER}/keymaps/${KEYMAP_FOLDER}/keymap.c" PARENT_SCOPE)
return()
endif()
get_filename_component(RELATIVE_KEYBOARD_FOLDER ${RELATIVE_KEYBOARD_FOLDER} DIRECTORY)
endwhile()
message(FATAL_ERROR "Could not find keymap.c in ${KEYBOARD_FOLDER_ABS}")
else()
if(EXISTS "${KEYBOARD_FOLDER_ABS}/keymap.c")
set(${KEYMAP_C_STR} "${KEYBOARD_FOLDER_ABS}/keymap.c" PARENT_SCOPE)
elseif(EXISTS "${KEYBOARD_FOLDER_ABS}/keymaps/${KEYMAP_FOLDER}/keymap.c")
set(${KEYMAP_C_STR} "${KEYBOARD_FOLDER_ABS}/keymaps/${KEYMAP_FOLDER}/keymap.c" PARENT_SCOPE)
else()
message(FATAL_ERROR "Could not find keymap.c in ${KEYBOARD_FOLDER_ABS}")
endif()
endif()
endif()
endfunction()

57
cmake/ResolveToolchain.cmake Normal file
View File

@ -0,0 +1,57 @@
function(resolve_toolchain PROCESSOR TOOLCHAIN_STR)
unset(${TOOLCHAIN_STR} PARENT_SCOPE)
if(
${PROCESSOR} MATCHES "^at.*"
)
set(${TOOLCHAIN_STR} "avr" PARENT_SCOPE)
include(FindAVRToolchain)
find_avr_toolchain()
elseif(
${PROCESSOR} MATCHES "^STM.*" OR
${PROCESSOR} MATCHES "^WB32.*" OR
${PROCESSOR} MATCHES "^MK.*" OR
${PROCESSOR} MATCHES "RP2040" OR
${PROCESSOR} MATCHES "^GD32.*"
)
set(${TOOLCHAIN_STR} "arm-none-eabi" PARENT_SCOPE)
include(FindARMToolchain)
find_arm_toolchain()
elseif(
${PROCESSOR} MATCHES "risc-v"
)
set(${TOOLCHAIN_STR} "riscv32-unknown-elf" PARENT_SCOPE)
else()
message(FATAL_ERROR "Could not find toolchain for ${PROCESSOR}")
endif()
endfunction()
function(find_toolchain TOOLCHAIN TOOLCHAIN_ROOT_STR)
unset(${TOOLCHAIN_STR} PARENT_SCOPE)
if(UNIX)
set(OS_SUFFIX "")
find_path(TOOLCHAIN_ROOT
NAMES
${TOOLCHAIN}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc/avr-gcc-12.1.0-x64-linux/bin/"
"${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-10.3-2021.10/bin/"
/usr/bin/
/usr/local/bin
/bin/
$ENV{AVR_ROOT}
)
elseif(WIN32)
set(OS_SUFFIX ".exe")
find_path(TOOLCHAIN_ROOT
NAMES
${TOOLCHAIN}-gcc${OS_SUFFIX}
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin"
"${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-10.3-2021.10/bin/"
$ENV{AVR_ROOT}
)
else()
message(FATAL_ERROR "Unsure how to handle this OS")
endif(UNIX)
set(${TOOLCHAIN_ROOT_STR} ${TOOLCHAIN_ROOT} PARENT_SCOPE)
endfunction(find_toolchain)

7
cmake/features/backlight.cmake
View File

@ -23,6 +23,9 @@ if(${BACKLIGHT_ENABLE} AND NOT ${NO_BACKLIGHT_PIN} STREQUAL "backlight-NOTFOUND"
endif()
endif()
target_include_directories(backlight PUBLIC quantum/backlight)
target_include_directories(quantum PUBLIC quantum/backlight)
target_link_libraries(backlight PUBLIC quantum)
target_include_directories(backlight PUBLIC drivers/oled)
# target_include_directories(backlight PUBLIC quantum/backlight)
# target_include_directories(quantum PUBLIC quantum/backlight)
target_link_libraries(backlight ${QMK_TARGET})
target_link_libraries(backlight quantum)
endif()

5
cmake/features/oled.cmake
View File

@ -5,9 +5,8 @@ if(${OLED_ENABLE})
platforms/${QMK_PLATFORM}/drivers/i2c_master.c)
add_compile_definitions(OLED_ENABLE)
target_include_directories(oled PUBLIC drivers)
target_include_directories(quantum PUBLIC drivers/oled)
target_include_directories(oled PUBLIC drivers/oled)
target_include_directories(oled PUBLIC platforms/${QMK_PLATFORM}/drivers)
target_link_libraries(oled PUBLIC quantum)
target_link_libraries(oled PUBLIC platform_avr)
target_link_libraries(oled ${QMK_TARGET})
target_link_libraries(oled platforms)
endif()

40
cmake/toolchains/arm-none-eabi.cmake
View File

@ -1,4 +1,6 @@
set(TRIPLE "arm-none-eabi")
include(ResolveToolchain)
set(QMK_TOOLCHAIN "arm-none-eabi")
set(QMK_PLATFORM "chibios")
set(QMK_PROTOCOL "chibios")
@ -7,25 +9,33 @@ if(UNIX)
elseif(WIN32)
set(OS_SUFFIX ".exe")
endif()
# include(FindARMToolchain)
# find_arm_toolchain()
find_toolchain(arm-none-eabi TOOLCHAIN_ROOT)
set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR arm)
set(CMAKE_CROSS_COMPILING 1)
set(CMAKE_MAKE_PROGRAM "${MAKE_ROOT}/make${OS_SUFFIX}" CACHE PATH "make" FORCE)
set(CMAKE_C_COMPILER "${TOOLCHAIN_ROOT}/${TRIPLE}-gcc${OS_SUFFIX}" CACHE PATH "gcc" FORCE)
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_ROOT}/${TRIPLE}-g++${OS_SUFFIX}" CACHE PATH "g++" FORCE)
set(CMAKE_AR "${TOOLCHAIN_ROOT}/${TRIPLE}-ar${OS_SUFFIX}" CACHE PATH "ar" FORCE)
set(CMAKE_AS "${TOOLCHAIN_ROOT}/${TRIPLE}-as${OS_SUFFIX}" CACHE PATH "as" FORCE)
set(CMAKE_LINKER "${TOOLCHAIN_ROOT}/${TRIPLE}-ld${OS_SUFFIX}" CACHE PATH "linker" FORCE)
set(CMAKE_NM "${TOOLCHAIN_ROOT}/${TRIPLE}-nm${OS_SUFFIX}" CACHE PATH "nm" FORCE)
set(CMAKE_OBJCOPY "${TOOLCHAIN_ROOT}/${TRIPLE}-objcopy${OS_SUFFIX}" CACHE PATH "objcopy" FORCE)
set(CMAKE_OBJDUMP "${TOOLCHAIN_ROOT}/${TRIPLE}-objdump${OS_SUFFIX}" CACHE PATH "objdump" FORCE)
set(CMAKE_STRIP "${TOOLCHAIN_ROOT}/${TRIPLE}-strip${OS_SUFFIX}" CACHE PATH "strip" FORCE)
set(CMAKE_RANLIB "${TOOLCHAIN_ROOT}/${TRIPLE}-ranlib${OS_SUFFIX}" CACHE PATH "ranlib" FORCE)
set(AVR_SIZE "${TOOLCHAIN_ROOT}/${TRIPLE}-size${OS_SUFFIX}" CACHE PATH "size" FORCE)
set(CMAKE_C_COMPILER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-gcc${OS_SUFFIX}" CACHE PATH "gcc" FORCE)
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-g++${OS_SUFFIX}" CACHE PATH "g++" FORCE)
set(CMAKE_AR "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ar${OS_SUFFIX}" CACHE PATH "ar" FORCE)
set(CMAKE_AS "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-as${OS_SUFFIX}" CACHE PATH "as" FORCE)
set(CMAKE_LINKER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ld${OS_SUFFIX}" CACHE PATH "linker" FORCE)
set(CMAKE_NM "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-nm${OS_SUFFIX}" CACHE PATH "nm" FORCE)
set(CMAKE_OBJCOPY "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-objcopy${OS_SUFFIX}" CACHE PATH "objcopy" FORCE)
set(CMAKE_OBJDUMP "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-objdump${OS_SUFFIX}" CACHE PATH "objdump" FORCE)
set(CMAKE_STRIP "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-strip${OS_SUFFIX}" CACHE PATH "strip" FORCE)
set(CMAKE_RANLIB "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ranlib${OS_SUFFIX}" CACHE PATH "ranlib" FORCE)
set(AVR_SIZE "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-size${OS_SUFFIX}" CACHE PATH "size" FORCE)
find_program(CMAKE_MAKE_PROGRAM NAME make
PATHS
$<$<WIN32>:"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin/">
$<$UNIX>:"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-linux/bin/">
/usr/bin/
/usr/local/bin
/bin/
)
add_compile_options(
$<$<COMPILE_LANGUAGE:C>:-std=gnu11>

122
cmake/toolchains/avr.cmake
View File

@ -4,7 +4,9 @@
# @author Natesh Narain
# @since Feb 06 2016
set(TRIPLE "avr")
include(ResolveToolchain)
set(QMK_TOOLCHAIN "avr")
set(QMK_PLATFORM "avr")
set(QMK_PROTOCOL "lufa")
@ -13,8 +15,8 @@ if(UNIX)
elseif(WIN32)
set(OS_SUFFIX ".exe")
endif()
# include(FindAVRToolchain)
# find_avr_toolchain()
find_toolchain(avr TOOLCHAIN_ROOT)
# setup the AVR compiler variables
@ -22,18 +24,17 @@ set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR avr)
set(CMAKE_CROSS_COMPILING 1)
set(CMAKE_MAKE_PROGRAM "${MAKE_ROOT}/make${OS_SUFFIX}" CACHE PATH "make" FORCE)
set(CMAKE_C_COMPILER "${TOOLCHAIN_ROOT}/${TRIPLE}-gcc${OS_SUFFIX}" CACHE PATH "gcc" FORCE)
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_ROOT}/${TRIPLE}-g++${OS_SUFFIX}" CACHE PATH "g++" FORCE)
set(CMAKE_AR "${TOOLCHAIN_ROOT}/${TRIPLE}-ar${OS_SUFFIX}" CACHE PATH "ar" FORCE)
set(CMAKE_AS "${TOOLCHAIN_ROOT}/${TRIPLE}-as${OS_SUFFIX}" CACHE PATH "as" FORCE)
set(CMAKE_LINKER "${TOOLCHAIN_ROOT}/${TRIPLE}-ld${OS_SUFFIX}" CACHE PATH "linker" FORCE)
set(CMAKE_NM "${TOOLCHAIN_ROOT}/${TRIPLE}-nm${OS_SUFFIX}" CACHE PATH "nm" FORCE)
set(CMAKE_OBJCOPY "${TOOLCHAIN_ROOT}/${TRIPLE}-objcopy${OS_SUFFIX}" CACHE PATH "objcopy" FORCE)
set(CMAKE_OBJDUMP "${TOOLCHAIN_ROOT}/${TRIPLE}-objdump${OS_SUFFIX}" CACHE PATH "objdump" FORCE)
set(CMAKE_STRIP "${TOOLCHAIN_ROOT}/${TRIPLE}-strip${OS_SUFFIX}" CACHE PATH "strip" FORCE)
set(CMAKE_RANLIB "${TOOLCHAIN_ROOT}/${TRIPLE}-ranlib${OS_SUFFIX}" CACHE PATH "ranlib" FORCE)
set(AVR_SIZE "${TOOLCHAIN_ROOT}/${TRIPLE}-size${OS_SUFFIX}" CACHE PATH "size" FORCE)
set(CMAKE_C_COMPILER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-gcc${OS_SUFFIX}" CACHE PATH "gcc" FORCE)
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-g++${OS_SUFFIX}" CACHE PATH "g++" FORCE)
set(CMAKE_AR "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ar${OS_SUFFIX}" CACHE PATH "ar" FORCE)
set(CMAKE_AS "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-as${OS_SUFFIX}" CACHE PATH "as" FORCE)
set(CMAKE_LINKER "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ld${OS_SUFFIX}" CACHE PATH "linker" FORCE)
set(CMAKE_NM "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-nm${OS_SUFFIX}" CACHE PATH "nm" FORCE)
set(CMAKE_OBJCOPY "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-objcopy${OS_SUFFIX}" CACHE PATH "objcopy" FORCE)
set(CMAKE_OBJDUMP "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-objdump${OS_SUFFIX}" CACHE PATH "objdump" FORCE)
set(CMAKE_STRIP "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-strip${OS_SUFFIX}" CACHE PATH "strip" FORCE)
set(CMAKE_RANLIB "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-ranlib${OS_SUFFIX}" CACHE PATH "ranlib" FORCE)
set(AVR_SIZE "${TOOLCHAIN_ROOT}/${QMK_TOOLCHAIN}-size${OS_SUFFIX}" CACHE PATH "size" FORCE)
# set(CMAKE_EXE_LINKER_FLAGS "-L /usr/lib/gcc/avr/4.8.2")
@ -46,6 +47,15 @@ find_program(AVR_UPLOAD
$ENV{AVR_ROOT}
)
find_program(CMAKE_MAKE_PROGRAM NAME make
PATHS
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-windows/bin/"
"${CMAKE_SOURCE_DIR}/toolchains/avr-gcc-12.1.0-x64-linux/bin/"
/usr/bin/
/usr/local/bin
/bin/
)
# setup the avr exectable macro
# set(AVR_LINKER_LIBS "-lc -lm -lgcc -Wl,-lprintf_flt -Wl,-u,vfprintf")
@ -53,8 +63,8 @@ find_program(AVR_UPLOAD
add_compile_options(
$<$<COMPILE_LANGUAGE:C>:-std=gnu11>
$<$<COMPILE_LANGUAGE:CXX>:-std=gnu++14>
-flto
# -mrelax
# -flto
-mrelax
-Os
-Wall
-Wstrict-prototypes
@ -78,7 +88,7 @@ add_compile_definitions(
F_CPU=16000000
F_USB=16000000UL
__AVR_ATmega32U4__
LTO_ENABLE
# LTO_ENABLE
)
add_link_options(
@ -89,87 +99,63 @@ add_link_options(
macro(add_qmk_executable target_name)
# add_subdirectory(${CMAKE_SOURCE_DIR}/platforms/avr platforms/avr)
# add_subdirectory(${CMAKE_SOURCE_DIR}/tmk_core/protocol/lufa tmk_core/protocol/lufa)
set(elf_file ${target_name}-${QMK_MCU}.elf)
set(QMK_TARGET ${target_name}-${QMK_MCU}.elf)
set(map_file ${target_name}-${QMK_MCU}.map)
set(hex_file ${target_name}-${QMK_MCU}.hex)
set(lst_file ${target_name}-${QMK_MCU}.lst)
add_link_options(-Wl,-Map=${map_file})
add_compile_options(
-mmcu=${QMK_MCU}
)
add_link_options(
-mmcu=${QMK_MCU}
-Wl,-Map=${map_file}
)
# create elf file
add_executable(${elf_file}
${ARGN}
)
add_executable(${QMK_TARGET} ${ARGN})
target_link_libraries(${elf_file}
PUBLIC
quantum
tmk_core_protocol
tmk_core_protocol_lufa
platforms
platforms_avr
)
# set_target_properties(
# ${elf_file}
target_link_libraries(${QMK_TARGET} quantum)
# set_target_properties(${QMK_TARGET}
# PROPERTIES
# COMPILE_FLAGS "-mmcu=${QMK_MCU} -g -w -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics"
# LINK_FLAGS "-mmcu=${QMK_MCU} -Wl,-Map,${map_file}"
# COMPILE_FLAGS "-mmcu=${QMK_MCU} ${COMPILE_OPTIONS}"
# LINK_FLAGS "-mmcu=${QMK_MCU} ${LINK_OPTIONS}"
# )
# generate the lst file
add_custom_command(
OUTPUT ${lst_file}
COMMAND
${CMAKE_OBJDUMP} -h -S ${elf_file} > ${lst_file}
DEPENDS ${elf_file}
COMMAND ${CMAKE_OBJDUMP} -h -S ${QMK_TARGET} > ${lst_file}
DEPENDS ${QMK_TARGET}
)
# create hex file
add_custom_command(
OUTPUT ${hex_file}
COMMAND
${CMAKE_OBJCOPY} -j .text -j .data -O ihex ${elf_file} ${hex_file}
DEPENDS ${elf_file}
COMMAND ${CMAKE_OBJCOPY} -j .text -j .data -O ihex ${QMK_TARGET} ${hex_file}
DEPENDS ${QMK_TARGET}
)
add_custom_command(
OUTPUT "print-size-${elf_file}"
COMMAND
${AVR_SIZE} ${elf_file}
DEPENDS ${elf_file}
OUTPUT "print-size-${QMK_TARGET}"
COMMAND ${AVR_SIZE} ${QMK_TARGET}
DEPENDS ${QMK_TARGET}
)
add_custom_command(
OUTPUT "print-size-${hex_file}"
COMMAND
${AVR_SIZE} ${hex_file}
COMMAND ${AVR_SIZE} ${hex_file}
DEPENDS ${hex_file}
)
# build the intel hex file for the device
add_custom_target(
${target_name}
ALL
DEPENDS ${hex_file} ${lst_file} "print-size-${elf_file}" "print-size-${hex_file}"
add_custom_target(${target_name} ALL
DEPENDS ${hex_file} ${lst_file} "print-size-${QMK_TARGET}" "print-size-${hex_file}"
)
set_target_properties(
${target_name}
PROPERTIES
OUTPUT_NAME ${elf_file}
set_target_properties(${target_name}
PROPERTIES OUTPUT_NAME ${QMK_TARGET}
)
endmacro(add_qmk_executable)

2
keyboards/CMakeLists.txt
View File

@ -1,5 +1,7 @@
include(ExternalProject)
include(AddKeyboard)
file(WRITE "${CMAKE_SOURCE_DIR}/build/targets" "")
if(DEFINED QMK_KEYBOARD_FOLDER)
if(NOT DEFINED QMK_KEYMAP_FOLDER)

3
platforms/CMakeLists.txt
View File

@ -1,5 +1,6 @@
add_library(platforms suspend.c synchronization_util.c timer.c)
target_include_directories(platforms PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(platforms PUBLIC quantum)
target_link_libraries(platforms ${QMK_TARGET})
target_link_libraries(platforms quantum)
add_subdirectory(${QMK_PLATFORM})

17
platforms/avr/CMakeLists.txt
View File

@ -1,9 +1,9 @@
add_compile_options(
-mmcu=${QMK_MCU}
)
add_link_options(
-mmcu=${QMK_MCU}
)
# add_compile_options(
# -mmcu=${QMK_MCU}
# )
# add_link_options(
# -mmcu=${QMK_MCU}
# )
add_library(platforms_avr
hardware_id.c
platform.c
@ -11,6 +11,9 @@ add_library(platforms_avr
timer.c
printf.c
bootloaders/bootloadhid.c
xprintf.S
)
target_include_directories(platforms_avr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(platforms_avr PUBLIC platforms quantum)
target_link_libraries(platforms_avr ${QMK_TARGET})
target_link_libraries(platforms_avr quantum)

5
platforms/chibios/CMakeLists.txt
View File

@ -1,3 +1,6 @@
add_link_options(
-mcpu=${QMK_MCU}
)
)
add_library(platforms_chibios)
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(platforms_chibios ${QMK_TARGET})

11
quantum/CMakeLists.txt
View File

@ -20,6 +20,7 @@ add_library(quantum
debounce/sym_defer_g.c
bootmagic/magic.c
)
target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/logging)
target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/keymap_extras)
@ -27,11 +28,11 @@ target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/process_ke
target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/sequencer)
target_include_directories(quantum PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/bootmagic)
target_link_libraries(quantum PUBLIC platforms)
if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "avr")
target_link_libraries(quantum PUBLIC platforms_avr)
endif()
target_link_libraries(quantum PUBLIC tmk_core_protocol)
target_link_libraries(quantum ${QMK_TARGET})
target_link_libraries(quantum platforms)
target_link_libraries(quantum platforms_${QMK_PLATFORM})
target_link_libraries(quantum tmk_core_protocol)
target_link_libraries(quantum tmk_core_protocol_${QMK_PROTOCOL})
# if no printf
# target_sources(quantum PRIVATE ${CMAKE_SOURCE_DIR}/lib/printf/src/printf/printf.c)

5
tmk_core/protocol/CMakeLists.txt
View File

@ -10,6 +10,9 @@ add_compile_definitions(
# NKRO_ENABLE
)
target_include_directories(tmk_core_protocol PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(tmk_core_protocol PUBLIC quantum)
target_link_libraries(tmk_core_protocol ${QMK_TARGET})
target_link_libraries(tmk_core_protocol quantum)
target_link_libraries(tmk_core_protocol tmk_core_protocol_${QMK_PROTOCOL})
target_link_libraries(tmk_core_protocol platforms_${QMK_PLATFORM})
add_subdirectory(${QMK_PROTOCOL})

8
tmk_core/protocol/lufa/CMakeLists.txt
View File

@ -23,5 +23,9 @@ find_package(lufa REQUIRED)
target_include_directories(tmk_core_protocol_lufa PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(tmk_core_protocol_lufa PUBLIC lufa)
target_link_libraries(tmk_core_protocol_lufa PUBLIC quantum)
target_link_libraries(tmk_core_protocol_lufa ${QMK_TARGET})
target_link_libraries(tmk_core_protocol_lufa quantum)
target_link_libraries(tmk_core_protocol_lufa tmk_core_protocol)
target_link_libraries(tmk_core_protocol_lufa lufa)
target_link_libraries(tmk_core_protocol_lufa platforms)
target_link_libraries(tmk_core_protocol_lufa platforms_${QMK_PLATFORM})