502 lines
20 KiB
Python
502 lines
20 KiB
Python
"""This script updates the sdkconfigs based on the menuconfig results in a given
|
|
build."""
|
|
|
|
import pathlib
|
|
import click
|
|
import copy
|
|
import kconfiglib
|
|
import os
|
|
|
|
OPT_SETTINGS = [
|
|
"CONFIG_ESP_ERR_TO_NAME_LOOKUP",
|
|
"CONFIG_ESP_CONSOLE_",
|
|
"CONFIG_CONSOLE_UART_",
|
|
"CONFIG_ESP_SYSTEM_PANIC_",
|
|
"CONFIG_ESP32S2_PANIC_",
|
|
"COMPILER_OPTIMIZATION_",
|
|
"CONFIG_ESP32S3_DEBUG_OCDAWARE",
|
|
"CONFIG_FREERTOS_ASSERT_",
|
|
"CONFIG_FREERTOS_DEBUG_OCDAWARE",
|
|
"CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER",
|
|
"CONFIG_HAL_ASSERTION_",
|
|
"CONFIG_LWIP_ESP_LWIP_ASSERT",
|
|
"CONFIG_OPTIMIZATION_ASSERTION_LEVEL",
|
|
"CONFIG_OPTIMIZATION_ASSERTIONS_",
|
|
"CONFIG_HAL_DEFAULT_ASSERTION_LEVEL",
|
|
"CONFIG_BOOTLOADER_LOG_LEVEL",
|
|
"LOG_DEFAULT_LEVEL",
|
|
]
|
|
|
|
TARGET_SETTINGS = [
|
|
"CONFIG_IDF_TARGET",
|
|
"CONFIG_IDF_FIRMWARE_CHIP_ID",
|
|
"CONFIG_BOOTLOADER_OFFSET_IN_FLASH",
|
|
"CONFIG_ESP_SLEEP_POWER_DOWN_FLASH",
|
|
"CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE",
|
|
"CONFIG_ESP_SYSTEM_MEMPROT_",
|
|
"CONFIG_ESP_MAIN_TASK_AFFINITY",
|
|
"CONFIG_ESP_WIFI_EXTERNAL_COEXIST_ENABLE",
|
|
"CONFIG_FREERTOS_UNICORE",
|
|
"CONFIG_FREERTOS_TICK_SUPPORT_CORETIMER",
|
|
"CONFIG_FREERTOS_CORETIMER_0",
|
|
"CONFIG_FREERTOS_CORETIMER_1",
|
|
"CONFIG_FREERTOS_SYSTICK_USES_CCOUNT",
|
|
"CONFIG_FREERTOS_OPTIMIZED_SCHEDULER",
|
|
"CONFIG_MBEDTLS_HARDWARE_GCM",
|
|
"CONFIG_ESP_SYSTEM_PD_FLASH",
|
|
"CONFIG_EXTERNAL_COEX_ENABLE",
|
|
"CONFIG_SDK_TOOLPREFIX",
|
|
"CONFIG_TOOLPREFIX",
|
|
"ESP_SLEEP_GPIO_RESET_WORKAROUND",
|
|
"CONFIG_ESP_PHY_ENABLE_USB",
|
|
"CONFIG_BT_SOC_SUPPORT_5_0",
|
|
"CONFIG_NIMBLE_PINNED_TO_CORE",
|
|
"CONFIG_BT_NIMBLE_PINNED_TO_CORE",
|
|
"CONFIG_BT_CTRL_PINNED_TO_CORE",
|
|
"CONFIG_SPIRAM_SPEED_2",
|
|
"CONFIG_SPIRAM_BANKSWITCH_ENABLE", # For ESP32
|
|
]
|
|
|
|
BOARD_SETTINGS = [
|
|
"CONFIG_LWIP_LOCAL_HOSTNAME",
|
|
]
|
|
|
|
FLASH_SIZE_SETTINGS = [
|
|
"CONFIG_ESPTOOLPY_FLASHSIZE",
|
|
"CONFIG_PARTITION_TABLE_CUSTOM_FILENAME",
|
|
"CONFIG_PARTITION_TABLE_FILENAME",
|
|
]
|
|
|
|
FLASH_MODE_SETTINGS = [
|
|
"CONFIG_ESPTOOLPY_FLASHMODE_",
|
|
"CONFIG_ESPTOOLPY_OCT_FLASH",
|
|
"CONFIG_ESPTOOLPY_FLASH_SAMBLE_MODE_",
|
|
]
|
|
|
|
FLASH_FREQ_SETTINGS = [
|
|
"CONFIG_ESPTOOLPY_FLASHFREQ_",
|
|
]
|
|
|
|
PSRAM_SETTINGS = ["CONFIG_SPIRAM"]
|
|
|
|
PSRAM_SIZE_SETTINGS = ["CONFIG_SPIRAM_TYPE_"]
|
|
|
|
PSRAM_MODE_SETTINGS = ["CONFIG_SPIRAM_MODE_"]
|
|
|
|
PSRAM_FREQ_SETTINGS = ["CONFIG_SPIRAM_SPEED_"]
|
|
|
|
# Some settings are target dependent but we want to always include them anyway
|
|
# because the files they are in will be used across targets.
|
|
ALWAYS_INCLUDE = FLASH_MODE_SETTINGS + FLASH_FREQ_SETTINGS + PSRAM_FREQ_SETTINGS
|
|
|
|
BLE_SETTINGS = ["CONFIG_BT_", "CONFIG_BLUEDROID_", "CONFIG_NIMBLE_", "CONFIG_SW_COEXIST_ENABLE"]
|
|
|
|
# boards/lilygo_ttgo_t8_s2_st7789/sdkconfig
|
|
# CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
|
|
|
|
# boards/morpheans_morphesp-240/sdkconfig
|
|
# CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
|
|
|
|
|
|
def matches_group(line, group):
|
|
for setting in group:
|
|
if setting in line:
|
|
return True
|
|
return False
|
|
|
|
|
|
def add_group(lines, last_group, current_group):
|
|
if not current_group or last_group != current_group:
|
|
while last_group and last_group[-1] not in current_group:
|
|
lines.append("# end of " + last_group[-1])
|
|
lines.append("")
|
|
last_group.pop()
|
|
for category in current_group:
|
|
if last_group and category in last_group:
|
|
continue
|
|
lines.append("#")
|
|
lines.append("# " + category)
|
|
lines.append("#")
|
|
return copy.copy(current_group)
|
|
return last_group
|
|
|
|
|
|
def sym_default(sym):
|
|
# Skip symbols that cannot be changed. Only check
|
|
# non-choice symbols, as selects don't affect choice
|
|
# symbols.
|
|
if not sym.choice and sym.visibility <= kconfiglib.expr_value(sym.rev_dep):
|
|
return True
|
|
|
|
# Skip symbols whose value matches their default
|
|
if sym.str_value == sym._str_default():
|
|
return True
|
|
|
|
# Skip symbols that would be selected by default in a
|
|
# choice, unless the choice is optional or the symbol type
|
|
# isn't bool (it might be possible to set the choice mode
|
|
# to n or the symbol to m in those cases).
|
|
if (
|
|
sym.choice
|
|
and not sym.choice.is_optional
|
|
and sym.choice._selection_from_defaults() is sym
|
|
and sym.orig_type is kconfiglib.BOOL
|
|
and sym.tri_value == 2
|
|
):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
@click.command()
|
|
@click.option("--debug")
|
|
@click.option("--board")
|
|
@click.option(
|
|
"--update_all",
|
|
is_flag=True,
|
|
default=False,
|
|
help="Updates the sdkconfigs outside of the board directory.",
|
|
)
|
|
def update(debug, board, update_all):
|
|
"""Updates related sdkconfig files based on the build directory version that
|
|
was likely modified by menuconfig."""
|
|
|
|
board_make = pathlib.Path(f"boards/{board}/mpconfigboard.mk")
|
|
psram_size = "0"
|
|
uf2_bootloader = None
|
|
ble_enabled = None
|
|
for line in board_make.read_text().split("\n"):
|
|
if "=" not in line or line.startswith("#"):
|
|
continue
|
|
key, value = line.split("=", maxsplit=1)
|
|
key = key.strip()
|
|
value = value.strip()
|
|
if key == "IDF_TARGET":
|
|
target = value
|
|
if uf2_bootloader is None:
|
|
uf2_bootloader = target not in ("esp32", "esp32c3", "esp32c6", "esp32h2")
|
|
if ble_enabled is None:
|
|
ble_enabled = target not in (
|
|
"esp32",
|
|
"esp32s2",
|
|
) # ESP32 is disabled by us. S2 doesn't support it.
|
|
elif key == "CIRCUITPY_ESP_FLASH_SIZE":
|
|
flash_size = value
|
|
elif key == "CIRCUITPY_ESP_FLASH_MODE":
|
|
flash_mode = value
|
|
elif key == "CIRCUITPY_ESP_FLASH_FREQ":
|
|
flash_freq = value
|
|
elif key == "CIRCUITPY_ESP_PSRAM_SIZE":
|
|
psram_size = value
|
|
elif key == "CIRCUITPY_ESP_PSRAM_MODE":
|
|
psram_mode = value
|
|
elif key == "CIRCUITPY_ESP_PSRAM_FREQ":
|
|
psram_freq = value
|
|
elif key == "UF2_BOOTLOADER":
|
|
uf2_bootloader = not (value == "0")
|
|
elif key == "CIRCUITPY_BLEIO":
|
|
ble_enabled = not (value == "0")
|
|
|
|
os.environ["IDF_TARGET"] = target
|
|
os.environ[
|
|
"COMPONENT_KCONFIGS_PROJBUILD_SOURCE_FILE"
|
|
] = f"build-{board}/esp-idf/kconfigs_projbuild.in"
|
|
os.environ["COMPONENT_KCONFIGS_SOURCE_FILE"] = f"build-{board}/esp-idf/kconfigs.in"
|
|
|
|
kconfig_path = pathlib.Path(f"build-{board}/esp-idf/kconfigs.in")
|
|
|
|
kconfig_path = pathlib.Path(f"esp-idf/Kconfig")
|
|
kconfig = kconfiglib.Kconfig(kconfig_path)
|
|
|
|
input_config = pathlib.Path(f"build-{board}/esp-idf/sdkconfig")
|
|
kconfig.load_config(input_config)
|
|
|
|
sdkconfigs = []
|
|
default_config = pathlib.Path("esp-idf-config/sdkconfig.defaults")
|
|
sdkconfigs.append(default_config)
|
|
if debug:
|
|
opt_config = pathlib.Path("esp-idf-config/sdkconfig-debug.defaults")
|
|
else:
|
|
opt_config = pathlib.Path("esp-idf-config/sdkconfig-opt.defaults")
|
|
sdkconfigs.append(opt_config)
|
|
size_options = ""
|
|
if flash_size == "2MB":
|
|
size_options = "-no-ota-no-uf2"
|
|
elif not uf2_bootloader:
|
|
# These boards don't have native USB.
|
|
size_options = "-no-uf2"
|
|
flash_size_config = pathlib.Path(
|
|
f"esp-idf-config/sdkconfig-flash-{flash_size}{size_options}.defaults"
|
|
)
|
|
flash_mode_config = pathlib.Path(f"esp-idf-config/sdkconfig-flash-{flash_mode}.defaults")
|
|
flash_freq_config = pathlib.Path(f"esp-idf-config/sdkconfig-flash-{flash_freq}.defaults")
|
|
sdkconfigs.extend((flash_size_config, flash_mode_config, flash_freq_config))
|
|
|
|
if psram_size != "0":
|
|
psram_config = pathlib.Path(f"esp-idf-config/sdkconfig-psram.defaults")
|
|
psram_size_config = pathlib.Path(f"esp-idf-config/sdkconfig-psram-{psram_size}.defaults")
|
|
psram_mode_config = pathlib.Path(f"esp-idf-config/sdkconfig-psram-{psram_mode}.defaults")
|
|
psram_freq_config = pathlib.Path(f"esp-idf-config/sdkconfig-psram-{psram_freq}.defaults")
|
|
sdkconfigs.extend((psram_config, psram_size_config, psram_mode_config, psram_freq_config))
|
|
target_config = pathlib.Path(f"esp-idf-config/sdkconfig-{target}.defaults")
|
|
sdkconfigs.append(target_config)
|
|
if ble_enabled:
|
|
ble_config = pathlib.Path(f"esp-idf-config/sdkconfig-ble.defaults")
|
|
sdkconfigs.append(ble_config)
|
|
board_config = pathlib.Path(f"boards/{board}/sdkconfig")
|
|
# Don't include the board file in cp defaults. The board may have custom
|
|
# overrides.
|
|
|
|
cp_kconfig_defaults = kconfiglib.Kconfig(kconfig_path)
|
|
for default_file in sdkconfigs:
|
|
cp_kconfig_defaults.load_config(default_file, replace=False)
|
|
|
|
board_settings = []
|
|
last_board_group = None
|
|
flash_size_settings = []
|
|
last_flash_size_group = None
|
|
flash_mode_settings = []
|
|
flash_freq_settings = []
|
|
psram_settings = []
|
|
last_psram_group = None
|
|
psram_size_settings = []
|
|
psram_mode_settings = []
|
|
psram_freq_settings = []
|
|
opt_settings = []
|
|
last_opt_group = None
|
|
target_settings = []
|
|
last_target_group = None
|
|
ble_settings = []
|
|
last_ble_group = None
|
|
default_settings = []
|
|
last_default_group = None
|
|
|
|
target_kconfig_snippets = set()
|
|
target_symbols = set()
|
|
|
|
current_group = []
|
|
|
|
for sym in kconfig.unique_defined_syms:
|
|
sym._visited = False
|
|
|
|
# This merges the normal `write_config`, `write_min_config` and CP settings to split into
|
|
# different files.
|
|
pending_nodes = [kconfig.top_node]
|
|
i = 0
|
|
while pending_nodes:
|
|
node = pending_nodes.pop()
|
|
if node is None:
|
|
current_group.pop()
|
|
continue
|
|
|
|
if node.item is kconfiglib.MENU:
|
|
if node.prompt:
|
|
print(" " * len(current_group), i, node.prompt[0])
|
|
i += 1
|
|
if node.next:
|
|
pending_nodes.append(node.next)
|
|
|
|
# if i > 300:
|
|
# break
|
|
|
|
# We have a configuration item.
|
|
item = node.item
|
|
if isinstance(item, kconfiglib.Symbol):
|
|
if item._visited:
|
|
continue
|
|
item._visited = True
|
|
|
|
config_string = item.config_string.strip()
|
|
if not config_string:
|
|
cp_sym = cp_kconfig_defaults.syms[item.name]
|
|
if cp_sym.str_value == "n":
|
|
config_string = f"# CONFIG_{item.name} is not set"
|
|
else:
|
|
continue
|
|
|
|
if node.list:
|
|
pending_nodes.append(node.list)
|
|
|
|
matches_cp_default = cp_kconfig_defaults.syms[item.name].str_value == item.str_value
|
|
matches_esp_default = sym_default(item)
|
|
|
|
print_debug = not matches_esp_default or (not update_all and not matches_cp_default)
|
|
if print_debug:
|
|
print(" " * len(current_group), i, config_string.strip())
|
|
|
|
# Some files are `rsource`d into another kconfig with $IDF_TARGET as
|
|
# part of the path. kconfiglib doesn't show this as a reference so
|
|
# we have to look ourselves.
|
|
target_reference = target in item.name_and_loc
|
|
if target_reference:
|
|
loc = item.name_and_loc.split("defined at ")[1].split(":")[0].replace(target, "*")
|
|
if loc not in target_kconfig_snippets:
|
|
differing_keys = set()
|
|
shared_keys = {}
|
|
first = True
|
|
for path in pathlib.Path(".").glob(loc):
|
|
kc = kconfiglib.Kconfig(path)
|
|
all_file_syms = set()
|
|
for sym in kc.unique_defined_syms:
|
|
all_file_syms.add(sym)
|
|
if sym.name in differing_keys:
|
|
continue
|
|
if first:
|
|
shared_keys[sym.name] = sym.str_value
|
|
elif (
|
|
sym.name not in shared_keys
|
|
or shared_keys[sym.name] != sym.str_value
|
|
):
|
|
differing_keys.add(sym.name)
|
|
if sym.name in shared_keys:
|
|
del shared_keys[sym.name]
|
|
# Any settings missing from a file are *not* shared.
|
|
shared_syms = set(shared_keys.keys())
|
|
for missing in shared_syms - all_file_syms:
|
|
differing_keys.add(missing)
|
|
del shared_keys[missing]
|
|
first = False
|
|
target_kconfig_snippets.add(loc)
|
|
target_symbols = target_symbols.union(differing_keys)
|
|
|
|
# kconfig settings can be set by others. item.referenced doesn't
|
|
# know this. So we collect all things that reference this using
|
|
# rev_dep.
|
|
all_references = set(item.referenced)
|
|
to_unpack = [item.rev_dep]
|
|
while to_unpack:
|
|
rdep = to_unpack.pop()
|
|
if isinstance(rdep, tuple):
|
|
to_unpack.extend(rdep)
|
|
elif isinstance(rdep, int):
|
|
# skip logic
|
|
pass
|
|
else:
|
|
all_references.add(rdep)
|
|
all_references.update(rdep.referenced)
|
|
psram_reference = False
|
|
for referenced in all_references:
|
|
if referenced.name.startswith("IDF_TARGET"):
|
|
target_reference = True
|
|
if referenced.name in target_symbols:
|
|
# Implicit target symbols
|
|
target_reference = True
|
|
if referenced.name == "SPIRAM":
|
|
psram_reference = True
|
|
|
|
if (not update_all and not matches_cp_default) or (
|
|
update_all
|
|
and matches_group(config_string, BOARD_SETTINGS)
|
|
and not matches_esp_default
|
|
):
|
|
print(" " * (len(current_group) + 1), "board")
|
|
last_board_group = add_group(board_settings, last_board_group, current_group)
|
|
board_settings.append(config_string)
|
|
elif update_all:
|
|
target_setting = target_reference or matches_group(config_string, TARGET_SETTINGS)
|
|
if matches_group(config_string, FLASH_SIZE_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "flash size")
|
|
last_flash_size_group = add_group(
|
|
flash_size_settings, last_flash_size_group, current_group
|
|
)
|
|
flash_size_settings.append(config_string)
|
|
elif matches_group(config_string, FLASH_MODE_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "flash mode")
|
|
flash_mode_settings.append(config_string)
|
|
elif matches_group(config_string, FLASH_FREQ_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "flash freq")
|
|
flash_freq_settings.append(config_string)
|
|
elif matches_group(config_string, PSRAM_SIZE_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "psram size")
|
|
psram_size_settings.append(config_string)
|
|
elif matches_group(config_string, PSRAM_MODE_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "psram mode")
|
|
psram_mode_settings.append(config_string)
|
|
elif (
|
|
matches_group(config_string, PSRAM_FREQ_SETTINGS)
|
|
and "26M" not in config_string
|
|
and "20M" not in config_string
|
|
):
|
|
# The ESP32S2 has two frequencies (20M and 26M) that aren't on the S3 or ESP32.
|
|
# So, put those in target settings.
|
|
print(" " * (len(current_group) + 1), "psram freq")
|
|
psram_freq_settings.append(config_string)
|
|
elif matches_esp_default:
|
|
if print_debug:
|
|
print(" " * (len(current_group) + 1), "default")
|
|
# Always document the above settings. Settings below should
|
|
# be non-default.
|
|
pass
|
|
elif matches_group(config_string, PSRAM_SETTINGS) or psram_reference:
|
|
print(" " * (len(current_group) + 1), "psram shared")
|
|
last_psram_group = add_group(psram_settings, last_psram_group, current_group)
|
|
psram_settings.append(config_string)
|
|
elif matches_group(config_string, OPT_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "opt")
|
|
last_opt_group = add_group(opt_settings, last_opt_group, current_group)
|
|
opt_settings.append(config_string)
|
|
elif target_setting:
|
|
print(" " * (len(current_group) + 1), "target")
|
|
last_target_group = add_group(
|
|
target_settings, last_target_group, current_group
|
|
)
|
|
target_settings.append(config_string)
|
|
elif matches_group(config_string, BLE_SETTINGS):
|
|
print(" " * (len(current_group) + 1), "ble")
|
|
last_ble_group = add_group(ble_settings, last_ble_group, current_group)
|
|
ble_settings.append(config_string)
|
|
else:
|
|
print(" " * (len(current_group) + 1), "all")
|
|
last_default_group = add_group(
|
|
default_settings, last_default_group, current_group
|
|
)
|
|
default_settings.append(config_string)
|
|
|
|
else:
|
|
if item is kconfiglib.COMMENT:
|
|
print("comment", repr(item))
|
|
elif item is kconfiglib.MENU:
|
|
if node.list:
|
|
current_group.append(node.prompt[0])
|
|
pending_nodes.append(None)
|
|
pending_nodes.append(node.list)
|
|
elif isinstance(item, kconfiglib.Choice):
|
|
# Choices are made up of individual symbols that we need to check.
|
|
pending_nodes.append(node.list)
|
|
else:
|
|
print("unknown", repr(item))
|
|
|
|
add_group(board_settings, last_board_group, current_group)
|
|
add_group(opt_settings, last_opt_group, current_group)
|
|
add_group(flash_size_settings, last_flash_size_group, current_group)
|
|
add_group(psram_settings, last_psram_group, current_group)
|
|
add_group(target_settings, last_target_group, current_group)
|
|
add_group(ble_settings, last_ble_group, current_group)
|
|
add_group(default_settings, last_default_group, current_group)
|
|
|
|
board_config.write_text("\n".join(board_settings))
|
|
if update_all:
|
|
# Add empty strings to get trailing newlines
|
|
flash_mode_settings.append("")
|
|
flash_freq_settings.append("")
|
|
flash_size_config.write_text("\n".join(flash_size_settings))
|
|
flash_mode_config.write_text("\n".join(flash_mode_settings))
|
|
flash_freq_config.write_text("\n".join(flash_freq_settings))
|
|
if psram_size != "0":
|
|
psram_size_settings.append("")
|
|
psram_mode_settings.append("")
|
|
psram_freq_settings.append("")
|
|
psram_config.write_text("\n".join(psram_settings))
|
|
psram_size_config.write_text("\n".join(psram_size_settings))
|
|
psram_mode_config.write_text("\n".join(psram_mode_settings))
|
|
psram_freq_config.write_text("\n".join(psram_freq_settings))
|
|
opt_config.write_text("\n".join(opt_settings))
|
|
default_config.write_text("\n".join(default_settings))
|
|
target_config.write_text("\n".join(target_settings))
|
|
if ble_settings:
|
|
ble_config.write_text("\n".join(ble_settings))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
update()
|