flipperzero-firmware/firmware.scons
Eric Betts 1975868ed8
PicoPass / iClass (#1298)
* add mdedtls for des3 implementation
* add localss from RfidResearchGroup/proxmark3
* picopass reader app and rfal for communicating with picopass cards
* always turn off field
* close storage when keys are not found
* Add mbedtls as submodule
* add mbedtl_config
* Switched to only including specific mbedtls files I need.  Thank you @kevinwallace
* cherry-pick kevinwallace sconsify
* scons for mbedtls/loclass
* Reset to ready state on error
* unsigned FC/CN
* clean FC/CN if not decoded

Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: あく <alleteam@gmail.com>
Co-authored-by: Kevin Wallace <git+flipperzero@kevin.wallace.seattle.wa.us>
2022-07-03 17:44:38 +09:00

283 lines
7.2 KiB
Plaintext

Import("ENV", "fw_build_meta")
import os
from fbt.util import link_dir
# Building initial C environment for libs
env = ENV.Clone(
tools=["compilation_db", "fwbin", "openocd", "fbt_apps"],
COMPILATIONDB_USE_ABSPATH=True,
BUILD_DIR=fw_build_meta["build_dir"],
IS_BASE_FIRMWARE=fw_build_meta["type"] == "firmware",
FW_FLAVOR=fw_build_meta["flavor"],
PLUGIN_ELF_DIR="${BUILD_DIR}",
LIB_DIST_DIR="${BUILD_DIR}/lib",
LINT_SOURCES=[
"applications",
],
LIBPATH=[
"${LIB_DIST_DIR}",
],
CPPPATH=[
"#/core",
"#/applications",
"#/firmware/targets/f${TARGET_HW}/ble_glue",
"#/firmware/targets/f${TARGET_HW}/fatfs",
"#/firmware/targets/f${TARGET_HW}/furi_hal",
"#/firmware/targets/f${TARGET_HW}/Inc",
"#/firmware/targets/furi_hal_include",
],
# Specific flags for building libraries - always do optimized builds
FW_LIB_OPTS={
"Default": {
"CCFLAGS": [
"-Os",
],
"CPPDEFINES": [
"NDEBUG",
"FURI_NDEBUG",
],
# You can add other entries named after libraries
# If they are present, they have precedence over Default
},
# for furi_check to respect build type
"core": {
"CCFLAGS": [
"-Os",
],
"CPPDEFINES": [
"NDEBUG",
"FURI_DEBUG" if ENV["DEBUG"] else "FURI_NDEBUG",
],
},
},
)
def ApplyLibFlags(env):
flags_to_apply = env["FW_LIB_OPTS"].get(
env.get("FW_LIB_NAME"),
env["FW_LIB_OPTS"]["Default"],
)
# print("Flags for ", env.get("FW_LIB_NAME", "Default"), flags_to_apply)
env.MergeFlags(flags_to_apply)
env.AddMethod(ApplyLibFlags)
Export("env")
if not env["VERBOSE"]:
env.SetDefault(
HEXCOMSTR="\tHEX\t${TARGET}",
BINCOMSTR="\tBIN\t${TARGET}",
DFUCOMSTR="\tDFU\t${TARGET}",
OPENOCDCOMSTR="\tFLASH\t${SOURCE}",
)
if fw_build_meta["type"] == "updater":
env.Append(
FIRMWARE_BUILD_CFG="updater",
RAM_EXEC=True,
CPPDEFINES=[
"FURI_RAM_EXEC",
],
)
else:
env.Append(
FIRMWARE_BUILD_CFG="firmware",
RAM_EXEC=False,
)
# print(env.Dump())
# Invoke child SCopscripts to populate global `env` + build their own part of the code
lib_targets = env.BuildModules(
[
"lib",
"assets",
"firmware",
"core",
],
)
# Now, env is fully set up with everything to build apps
fwenv = env.Clone()
# Set up additional app-specific build flags
SConscript("site_scons/firmwareopts.scons", exports={"ENV": fwenv})
# Set up app configuration
if env["IS_BASE_FIRMWARE"]:
fwenv.Append(APPS=fwenv["FIRMWARE_APPS"].get(fwenv.subst("$FIRMWARE_APP_SET")))
else:
fwenv.Append(APPS=["updater"])
if extra_int_apps := GetOption("extra_int_apps"):
fwenv.Append(APPS=extra_int_apps.split(","))
fwenv.LoadApplicationManifests()
fwenv.PrepareApplicationsBuild()
# Build external apps
extapps = SConscript("applications/extapps.scons", exports={"ENV": fwenv})
# Add preprocessor definitions for current set of apps
fwenv.AppendUnique(
CPPDEFINES=fwenv["APPBUILD"].get_apps_cdefs(),
)
# Build applications.c for selected services & apps
# Depends on virtual value-only node, so it only gets rebuilt when set of apps changes
apps_c = fwenv.ApplicationsC(
"applications/applications.c",
Value(fwenv["APPS"]),
)
sources = [apps_c]
# Gather sources only from app folders from current configuration
for app_folder in fwenv["APPBUILD"].get_builtin_app_folders():
sources += fwenv.GlobRecursive("*.c*", os.path.join("applications", app_folder))
fwenv.AppendUnique(
LINKFLAGS=[
"-specs=nano.specs",
"-specs=nosys.specs",
"-Wl,--start-group",
"-lstdc++",
"-lsupc++",
"-Wl,--end-group",
"-Wl,--gc-sections",
"-Wl,--undefined=uxTopUsedPriority",
"-Wl,--wrap,_malloc_r",
"-Wl,--wrap,_free_r",
"-Wl,--wrap,_calloc_r",
"-Wl,--wrap,_realloc_r",
"-u",
"_printf_float",
"-n",
],
)
# Debug
# print(fwenv.Dump())
# Full firmware definition
fwelf = fwenv["FW_ELF"] = fwenv.Program(
"${FIRMWARE_BUILD_CFG}",
sources,
LIBS=[
"flipper${TARGET_HW}",
"core",
"freertos",
"stm32cubewb",
"hwdrivers",
"fatfs",
"littlefs",
"subghz",
"flipperformat",
"toolbox",
"microtar",
"usb_stm32",
"st25rfal002",
"infrared",
"appframe",
"assets",
"misc",
# 2nd round
"flipperformat",
"toolbox",
"mbedtls",
"loclass",
],
)
def link_elf_dir_as_latest(env, elf_target):
# Ugly way to check if updater-related targets were requested
elf_dir = elf_target.Dir(".")
explicitly_building_updater = False
# print("BUILD_TARGETS:", ','.join(BUILD_TARGETS))
for build_target in BUILD_TARGETS:
# print(">>> ", str(build_target))
if "updater" in str(build_target):
explicitly_building_updater = True
latest_dir = env.Dir("#build/latest")
link_this_dir = True
if explicitly_building_updater:
# If updater is explicitly requested, link to the latest updater
# Otherwise, link to the latest firmware
link_this_dir = not env["IS_BASE_FIRMWARE"]
if link_this_dir:
print(f"Setting {elf_dir} as latest built dir")
return link_dir(latest_dir.abspath, elf_dir.abspath, env["PLATFORM"] == "win32")
def link_latest_dir(env, target, source):
return link_elf_dir_as_latest(env, target[0])
# Make it depend on everything child builders returned
Depends(fwelf, lib_targets)
AddPostAction(fwelf, fwenv["APPBUILD_DUMP"])
AddPostAction(fwelf, Action("@$SIZECOM"))
AddPostAction(fwelf, Action(link_latest_dir, None))
link_dir_command = fwenv["LINK_DIR_CMD"] = fwenv.PhonyTarget(
"${FIRMWARE_BUILD_CFG}" + "_latest",
Action(lambda target, source, env: link_elf_dir_as_latest(env, source[0]), None),
source=fwelf,
)
fwhex = fwenv["FW_HEX"] = fwenv.HEXBuilder("${FIRMWARE_BUILD_CFG}")
fwbin = fwenv["FW_BIN"] = fwenv.BINBuilder("${FIRMWARE_BUILD_CFG}")
fwdfu = fwenv["FW_DFU"] = fwenv.DFUBuilder("${FIRMWARE_BUILD_CFG}")
Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_dfu", fwdfu)
fwdump = fwenv.ObjDump("${FIRMWARE_BUILD_CFG}")
Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_list", fwdump)
# Additional FW-related pseudotargets
flash = fwenv["FW_FLASH"] = fwenv.OpenOCDFlash(
"#build/oocd-${FIRMWARE_BUILD_CFG}-flash.flag",
"${FIRMWARE_BUILD_CFG}",
OPENOCD_COMMAND='-c "program ${SOURCE.posix} reset exit ${IMAGE_BASE_ADDRESS}"',
)
if fwenv["FORCE"]:
fwenv.AlwaysBuild(flash)
fwenv.Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_flash", flash)
if fwenv["IS_BASE_FIRMWARE"]:
fwenv.Alias("flash", flash)
# Compile DB generation
fwcdb = fwenv["FW_CDB"] = fwenv.CompilationDatabase("compile_commands.json")
fwenv.Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_cdb", fwcdb)
artifacts = [
fwhex,
fwbin,
fwdfu,
env["FW_VERSION_JSON"],
fwcdb,
]
fwenv["FW_ARTIFACTS"] = artifacts
Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_all", artifacts)
Return("fwenv")