first commit

Author: ohenley

.gitignore

@@ -0,0 +1 @@
+install/

README.md

@@ -0,0 +1,84 @@
+# STM32F407 Runtimes
+
+This repository generates GNAT bare-metal runtimes for STM32F407 targets.
+
+Supported runtime profiles:
+- `light`
+- `light-tasking`
+- `embedded`
+
+## Using a runtime from Alire
+
+Example using `light-tasking-stm32f407`:
+
+1. Add the crate to your project's `alire.toml`:
+
+```toml
+[[depends-on]]
+light_tasking_stm32f407 = "*"
+```
+
+2. In your project `.gpr`, reference and use the runtime project:
+
+```ada
+with "runtime_build.gpr";
+
+project App is
+   for Target use runtime_build'Target;
+   for Runtime ("Ada") use runtime_build'Runtime ("Ada");
+
+   package Linker is
+      for Switches ("Ada") use Runtime_Build.Linker_Switches;
+   end Linker;
+end App;
+```
+
+## Runtime Clock Configuration (important)
+
+Clock setup is controlled by crate configuration variables in your
+application's `alire.toml`.
+
+Default behavior is a 168 MHz SYSCLK from HSI through PLL.
+
+For STM32F407 Discovery (8 MHz HSE crystal), a typical configuration is:
+
+```toml
+[configuration.values]
+# HSE on Discovery board
+light_tasking_stm32f407.HSE_Clock_Frequency = 8000000
+light_tasking_stm32f407.HSE_Bypass = false
+
+# Use PLL as SYSCLK source
+light_tasking_stm32f407.SYSCLK_Src = "PLLCLK"
+light_tasking_stm32f407.PLL_Src = "HSE"
+
+# 8 MHz -> (N/M)=336/8 => 336 MHz VCO
+light_tasking_stm32f407.PLL_M_Div = 8
+light_tasking_stm32f407.PLL_N_Mul = 336
+
+# SYSCLK = VCO / 2 = 168 MHz
+light_tasking_stm32f407.PLL_P_Div = "DIV2"
+
+# 48 MHz domain for USB/SDIO/RNG
+light_tasking_stm32f407.PLL_Q_Div = 7
+
+# Bus prescalers
+light_tasking_stm32f407.AHB_Pre  = "DIV1"
+light_tasking_stm32f407.APB1_Pre = "DIV4"
+light_tasking_stm32f407.APB2_Pre = "DIV2"
+```
+
+## Note about timing accuracy
+
+A timing issue where `delay 1.0` behaved like ~4 seconds was caused by an
+incorrect PLLP register encoding in `setup_pll.adb`. This repository now uses
+the correct STM32F4 encoding (`00=/2, 01=/4, 10=/6, 11=/8`) consistently.
+
+## Generation templates
+
+The generated crate metadata and examples are based on:
+- `templates/alire.toml.in`
+- `templates/stm32f407_runtime_config.ads.in`
+- `stm32f407_src/setup_pll.adb`
+
+If you regenerate runtimes, these sources carry the fixed behavior.

build-rts.py

@@ -0,0 +1,94 @@
+# This script extends bb-runtimes to define the stm32f407 target
+
+import sys
+import os
+import pathlib
+
+# Add bb-runtimes to the search path so that we can include and extend it
+sys.path.append(str(pathlib.Path(__file__).parent / "bb-runtimes"))
+
+import arm.cortexm
+import build_rts
+from support import add_source_search_path
+
+
+class ArmV7MArch_Patched(arm.cortexm.ArmV7MArch):
+    def __init__(self):
+        super(ArmV7MArch_Patched, self).__init__()
+        # Use our own patched version of s-bbbosu.adb which has a fix that is
+        # not yet merged upstream (the fix ensures that Interrupt_Wrapper is
+        # called with interrupts disabled to avoid a race condition with
+        # nested interrupts).
+        # See: https://forum.ada-lang.io/t/a-bug-in-stm32-bareboard-runtimes/2168
+        self.remove_source("s-bbbosu.adb")
+        self.add_gnarl_sources("stm32f407_src/s-bbbosu.adb")
+
+
+class Stm32F407(arm.cortexm.CortexM4F):
+    @property
+    def name(self):
+        return "stm32f407"
+
+    @property
+    def parent(self):
+        return ArmV7MArch_Patched
+
+    @property
+    def use_semihosting_io(self):
+        return True
+
+    @property
+    def loaders(self):
+        return ("ROM", "RAM")
+
+    @property
+    def system_ads(self):
+        return {
+            "light": "system-xi-arm.ads",
+            "light-tasking": "system-xi-cortexm4-sfp.ads",
+            "embedded": "system-xi-cortexm4-full.ads",
+        }
+
+    def __init__(self):
+        super(Stm32F407, self).__init__()
+
+        self.add_linker_script("stm32f407_src/ld/common-RAM.ld")
+        self.add_linker_script("stm32f407_src/ld/common-ROM.ld")
+
+        # Common source files
+        self.add_gnat_sources(
+            "bb-runtimes/arm/stm32/start-common.S",
+            "bb-runtimes/arm/stm32/start-ram.S",
+            "bb-runtimes/arm/stm32/start-rom.S",
+            "stm32f407_src/setup_pll.ads",
+            "stm32f407_src/setup_pll.adb",
+            "stm32f407_src/s-bbpara.ads",
+            "stm32f407_src/s-bbbopa.ads",
+            "stm32f407_src/s-bbmcpa.ads",
+            "stm32f407_src/svd/handler.S",
+            "stm32f407_src/svd/i-stm32.ads",
+            "stm32f407_src/svd/i-stm32-flash.ads",
+            "stm32f407_src/svd/i-stm32-pwr.ads",
+            "stm32f407_src/svd/i-stm32-rcc.ads",
+        )
+
+        self.add_gnarl_sources(
+            "stm32f407_src/svd/a-intnam-F407.ads",
+        )
+
+
+def build_configs(target):
+    if target == "stm32f407":
+        return Stm32F407()
+    else:
+        assert False, "unexpected target: %s" % target
+
+def patch_bb_runtimes():
+    """Patch some parts of bb-runtimes to use our own targets and data"""
+    add_source_search_path(os.path.dirname(__file__))
+
+    build_rts.build_configs = build_configs
+
+if __name__ == "__main__":
+    patch_bb_runtimes()
+    build_rts.main()

crateify.py

@@ -0,0 +1,187 @@
+# This script takes the stm32f407 runtimes generated by build-rts.py and
+# patches them to turn them into an Alire crate.
+#
+# In particular it:
+#  - adds an alire.toml
+#  - overwrites runtime_build.gpr and ravenscar_build.gpr with our own versions
+#    to take advantage of crate configuration variables.
+#  - patches target_options.gpr to add a prefix to the BUILD and LIBRARY_TYPE
+#    GPR scenario variables.
+#  - adds stm32f407_runtime_config.ads which renames the crate config package
+#    generated by Alire so that the common runtime sources can access the
+#    config via one common package name.
+#  - installs extra linker scripts with the directory hierarchy intact
+#    (bb-runtimes flattens the directory structure when installing sources).
+
+import argparse
+import pathlib
+import shutil
+from typing import Dict
+
+
+def patch_ravenscar_build_gpr(gpr_file: pathlib.Path, profile: str, target: str):
+    """Patch the ravenscar_build.gpr file to add some style switches"""
+
+    # Change "light-tasking" to "light_tasking"
+    profile = profile.replace("-", "_")
+
+    with open(gpr_file, "r") as f:
+        content = f.read()
+
+    # Add -gnaty-d to the switches used to build the runtime. This fixes style
+    # warnings about line endings for packages which "with" the crate
+    # configuration package generated by Alire, which uses CRLF line endings on
+    # Windows.
+    content = content.replace(
+        f'for Default_Switches ("Ada") use Target_Options.GNARL_ADAFLAGS',
+        f'for Default_Switches ("Ada") use Target_Options.GNARL_ADAFLAGS & ("-gnaty-d")',
+    )
+
+    with open(gpr_file, "w") as f:
+        f.write(content)
+
+
+def patch_target_options(gpr_file: pathlib.Path, profile: str, target: str):
+    """Patch the target_options.gpr file to add the crate name as a prefix
+    to GPR variables.
+
+    E.g. for light-tasking-stm32f407:
+    BUILD becomes LIGHT_TASKING_STM32F407_BUILD
+    LIBRARY_TYPE becomes LIGHT_TASKING_STM32F407_LIBRARY_TYPE
+
+    This follows the Alire best practices and allows the build mode to be
+    set for just the runtime crate if need be.
+    """
+
+    # Change "light-tasking" to "light_tasking"
+    profile = profile.replace("-", "_")
+
+    with open(gpr_file, "r") as f:
+        content = f.read()
+
+    content = content.replace(
+        f'"BUILD"',
+        f'"{profile.upper()}_{target.upper()}_BUILD"',
+    )
+    content = content.replace(
+        f'"LIBRARY_TYPE"',
+        f'"{profile.upper()}_{target.upper()}_LIBRARY_TYPE"',
+    )
+
+    with open(gpr_file, "w") as f:
+        f.write(content)
+
+
+def gen_from_template(
+    template_file: pathlib.Path,
+    out_file: pathlib.Path,
+    template_values: Dict[str, str],
+):
+    with open(template_file, "r") as f:
+        content = f.read()
+
+    for key, value in template_values.items():
+        content = content.replace(f"$({key})", value)
+
+    with open(out_file, "w", newline="\n") as f:
+        f.write(content)
+
+
+def capitalize_underscored(s: str):
+    return "_".join(x.capitalize() for x in s.split("_"))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--runtime-dir", type=str, help="Path to the runtime directory to patch"
+    )
+    parser.add_argument(
+        "--profile",
+        type=str,
+        choices=["light", "light-tasking", "embedded"],
+        help="The runtime profile",
+    )
+    parser.add_argument(
+        "--version",
+        type=str,
+        default="15.0.0-dev",
+        help="Version string to put in the alire.toml file",
+    )
+
+    args = parser.parse_args()
+
+    runtime_dir = pathlib.Path(args.runtime_dir)
+    profile = args.profile
+    pretty_target = "STM32F407"
+    target = "stm32f407"
+
+    has_libgnarl = (runtime_dir / "ravenscar_build.gpr").exists()
+
+    project_files = ["runtime_build.gpr"]
+    if has_libgnarl:
+        project_files.append("ravenscar_build.gpr")
+
+    patch_target_options(
+        gpr_file=runtime_dir / "target_options.gpr", profile=profile, target=target
+    )
+
+    if has_libgnarl:
+        patch_ravenscar_build_gpr(
+            gpr_file=runtime_dir / "ravenscar_build.gpr", profile=profile, target=target
+        )
+
+    profile_underscored = profile.replace("-", "_")
+
+    # light and light-tasking require "Ada" and "Asm_Cpp".
+    # embedded also requires "C".
+    languages_list = ["Ada", "Asm_Cpp"]
+    if profile == "embedded":
+        languages_list.append("C")
+
+    template_values = {
+        "profile": profile,
+        "profile_underscored": profile_underscored,
+        "target": target,
+        "pretty_target": pretty_target,
+        "project_files_list": str(project_files),
+        "version": args.version,
+        "languages_list": ", ".join(f'"{lang}"' for lang in languages_list)
+    }
+
+    templates_dir = pathlib.Path(__file__).parent / "templates"
+
+    gen_from_template(
+        template_file=templates_dir / "alire.toml.in",
+        out_file=runtime_dir / "alire.toml",
+        template_values=template_values,
+    )
+
+    gen_from_template(
+        template_file=templates_dir / "runtime_build.gpr.in",
+        out_file=runtime_dir / "runtime_build.gpr",
+        template_values=template_values,
+    )
+
+    if has_libgnarl:
+        gen_from_template(
+            template_file=templates_dir / "ravenscar_build.gpr.in",
+            out_file=runtime_dir / "ravenscar_build.gpr",
+            template_values=template_values,
+        )
+
+    gen_from_template(
+        template_file=templates_dir / "stm32f407_runtime_config.ads.in",
+        out_file=runtime_dir / "gnat_user" / "stm32f407_runtime_config.ads",
+        template_values=template_values,
+    )
+
+    shutil.copytree(
+        src=pathlib.Path(__file__).parent / "stm32f407_src" / "ld",
+        dst=runtime_dir / "ld",
+        dirs_exist_ok=True,
+    )
+
+
+if __name__ == "__main__":
+    main()