feat: integrate U-Boot boot flow (#4)

Author: koehlma

.gitignore

@@ -1,2 +1,3 @@
 .rugpi
-/target
+/target
+/playground

.vscode/cspell.json

@@ -36,6 +36,7 @@
     "rbind",
     "resolv",
     "rootfstype",
+    "rootwait",
     "rugpi",
     "rustfmt",
     "sfdisk",
@@ -45,6 +46,7 @@
     "tempdir",
     "tmpfs",
     "tryboot",
+    "uboot",
     "unistd",
     "upperdir",
     "uuid",

Cargo.lock

@@ -14,4 +14,4 @@ anyhow = "1.0.71"
 camino = "1.1.6"
 clap = { version = "4.3", features = ["derive"] }
 serde = { version = "1", features = ["derive"] }
-xscript = "0.2.0"
+xscript = "0.2.0"

Cargo.toml

@@ -6,7 +6,7 @@ use std::{
 };
 
 use camino::Utf8PathBuf;
-use rugpi_common::Anyhow;
+use rugpi_common::{boot::BootFlow, Anyhow};
 use serde::{Deserialize, Serialize};
 
 use crate::recipes::{ParameterValue, RecipeName};
@@ -17,15 +17,18 @@ pub struct BakeryConfig {
     /// The recipes to include.
     #[serde(default)]
     pub recipes: HashSet<RecipeName>,
-    /// Include firmware files for Pi 4.
-    #[serde(default)]
-    pub include_firmware: IncludeFirmware,
     /// The recipes to exclude.
     #[serde(default)]
     pub exclude: HashSet<RecipeName>,
     /// Parameters for the recipes.
     #[serde(default)]
     pub parameters: HashMap<RecipeName, HashMap<String, ParameterValue>>,
+    /// Indicates whether to include firmware files in the image.
+    #[serde(default)]
+    pub include_firmware: IncludeFirmware,
+    /// Indicates which boot flow to use for the image.
+    #[serde(default)]
+    pub boot_flow: BootFlow,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]

crates/rugpi-bakery/src/config.rs

@@ -5,15 +5,16 @@ use std::fs;
 use camino::Utf8Path;
 use clap::Parser;
 use rugpi_common::{
+    boot::{uboot::UBootEnv, BootFlow},
     loop_dev::LoopDevice,
     mount::Mounted,
     partitions::{get_disk_id, mkfs_ext4, mkfs_vfat, sfdisk_apply_layout, sfdisk_image_layout},
-    patch_cmdline, patch_config, Anyhow,
+    patch_boot, patch_config, Anyhow,
 };
 use tempdir::TempDir;
 use xscript::{run, Run};
 
-use crate::config::load_config;
+use crate::config::{load_config, BakeryConfig, IncludeFirmware};
 
 #[derive(Debug, Parser)]
 pub struct BakeTask {
@@ -39,35 +40,58 @@ pub fn run(task: &BakeTask) -> Anyhow<()> {
     mkfs_vfat(loop_device.partition(1), "CONFIG")?;
     mkfs_vfat(loop_device.partition(2), "BOOT-A")?;
     mkfs_ext4(loop_device.partition(5), "system-a")?;
-    let temp_dir = TempDir::new("rugpi")?;
-    let temp_dir_path = Utf8Path::from_path(temp_dir.path()).unwrap();
-    {
-        let _mounted_root = Mounted::mount(loop_device.partition(5), temp_dir_path)?;
-        let boot_dir = temp_dir_path.join("boot");
-        fs::create_dir_all(&boot_dir)?;
-        let _mounted_boot = Mounted::mount(loop_device.partition(2), &boot_dir)?;
-        println!("Writing system files...");
-        run!(["tar", "-x", "-f", &task.archive, "-C", temp_dir_path])?;
-        println!("Patching `cmdline.txt`...");
-        patch_cmdline(
-            boot_dir.join("cmdline.txt"),
-            format!("PARTUUID={disk_id}-05"),
-        )?;
-        println!("Patching `config.txt`...");
-        patch_config(boot_dir.join("config.txt"))?;
+    let root_dir = TempDir::new("rugpi")?;
+    let root_dir_path = Utf8Path::from_path(root_dir.path()).unwrap();
+    let mounted_root = Mounted::mount(loop_device.partition(5), root_dir_path)?;
+    let mut boot_dir = root_dir_path.join("boot");
+    let boot_firmware_dir = boot_dir.join("firmware");
+    if boot_firmware_dir.exists() {
+        boot_dir = boot_firmware_dir;
     }
-    {
-        let _mounted_config = Mounted::mount(loop_device.partition(1), temp_dir_path)?;
-        run!(["cp", "-rTp", "/usr/share/rugpi/files/config", temp_dir_path])?;
-        match config.include_firmware {
-            crate::config::IncludeFirmware::None => { /* Do not include any firmware. */ }
-            crate::config::IncludeFirmware::Pi4 => include_pi4_firmware(&temp_dir_path)?,
-            crate::config::IncludeFirmware::Pi5 => include_pi5_firmware(&temp_dir_path)?,
-        }
+    fs::create_dir_all(&boot_dir)?;
+    let mounted_boot = Mounted::mount(loop_device.partition(2), &boot_dir)?;
+    let config_dir = TempDir::new("rugpi")?;
+    let config_dir_path = Utf8Path::from_path(config_dir.path()).unwrap();
+    let mounted_config = Mounted::mount(loop_device.partition(1), &config_dir_path)?;
+    let ctx = BakeCtx {
+        config,
+        mounted_boot,
+        mounted_root,
+        mounted_config,
+    };
+
+    run!(["tar", "-x", "-f", &task.archive, "-C", root_dir_path])?;
+    println!("Patching boot configuration...");
+    patch_boot(ctx.mounted_boot.path(), format!("PARTUUID={disk_id}-05"))?;
+    println!("Patching `config.txt`...");
+    patch_config(boot_dir.join("config.txt"))?;
+
+    match ctx.config.boot_flow {
+        BootFlow::Tryboot => setup_tryboot_boot_flow(&ctx)?,
+        BootFlow::UBoot => setup_uboot_boot_flow(&ctx)?,
+    }
+
+    std::fs::copy(
+        "/usr/share/rugpi/boot/u-boot/bin/second.scr",
+        ctx.mounted_boot.path().join("second.scr"),
+    )?;
+
+    match ctx.config.include_firmware {
+        IncludeFirmware::None => { /* Do not include any firmware. */ }
+        IncludeFirmware::Pi4 => include_pi4_firmware(&root_dir_path)?,
+        IncludeFirmware::Pi5 => include_pi5_firmware(&root_dir_path)?,
     }
     Ok(())
 }
 
+struct BakeCtx {
+    config: BakeryConfig,
+    mounted_boot: Mounted,
+    #[allow(unused)]
+    mounted_root: Mounted,
+    mounted_config: Mounted,
+}
+
 fn calculate_image_size(archive: &Utf8Path) -> Anyhow<u64> {
     let archive_bytes = fs::metadata(archive)?.len();
     let total_bytes = archive_bytes + (256 + 128 + 128) * 1024 * 1024;
@@ -76,6 +100,54 @@ fn calculate_image_size(archive: &Utf8Path) -> Anyhow<u64> {
     Ok(actual_blocks * 4096)
 }
 
+fn setup_tryboot_boot_flow(ctx: &BakeCtx) -> Anyhow<()> {
+    run!([
+        "cp",
+        "-rTp",
+        "/usr/share/rugpi/boot/tryboot",
+        ctx.mounted_config.path()
+    ])?;
+    Ok(())
+}
+
+fn setup_uboot_boot_flow(ctx: &BakeCtx) -> Anyhow<()> {
+    run!([
+        "cp",
+        "-rTp",
+        ctx.mounted_boot.path(),
+        ctx.mounted_config.path()
+    ])?;
+    std::fs::remove_file(&ctx.mounted_config.path().join("kernel8.img"))?;
+    std::fs::copy(
+        "/usr/share/rugpi/boot/u-boot/arm64_config.txt",
+        ctx.mounted_config.path().join("config.txt"),
+    )?;
+    std::fs::copy(
+        "/usr/share/rugpi/boot/u-boot/bin/u-boot-arm64.bin",
+        ctx.mounted_config.path().join("u-boot-arm64.bin"),
+    )?;
+    std::fs::copy(
+        "/usr/share/rugpi/boot/u-boot/bin/boot.scr",
+        ctx.mounted_config.path().join("boot.scr"),
+    )?;
+    std::fs::write(ctx.mounted_config.path().join("cmdline.txt"), "")?;
+
+    let mut env = UBootEnv::new();
+    env.set("bootpart", "2".to_owned());
+    env.save(ctx.mounted_config.path().join("bootpart.default.env"))?;
+
+    let mut env = UBootEnv::new();
+    env.set("boot_spare", "0".to_owned());
+    env.save(ctx.mounted_config.path().join("boot_spare.disabled.env"))?;
+    env.save(ctx.mounted_config.path().join("boot_spare.env"))?;
+
+    let mut env = UBootEnv::new();
+    env.set("boot_spare", "1".to_owned());
+    env.save(ctx.mounted_config.path().join("boot_spare.enabled.env"))?;
+
+    Ok(())
+}
+
 fn include_pi4_firmware(autoboot_path: &Utf8Path) -> Anyhow<()> {
     run!([
         "cp",

crates/rugpi-bakery/src/tasks/bake.rs

@@ -11,5 +11,8 @@ homepage.workspace = true
 [dependencies]
 anyhow.workspace = true
 camino.workspace = true
+crc32fast = "1.3.2"
 indoc = "2.0.3"
+serde.workspace = true
+thiserror = "1.0.50"
 xscript.workspace = true

crates/rugpi-common/Cargo.toml

@@ -0,0 +1,25 @@
+use serde::{Deserialize, Serialize};
+
+pub mod uboot;
+
+/// Rugpi boot flows.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum BootFlow {
+    /// Use the `tryboot` feature for booting and partition switching.
+    #[default]
+    Tryboot,
+    /// Use U-Boot for booting and partition switching.
+    #[serde(rename = "u-boot")]
+    UBoot,
+}
+
+impl BootFlow {
+    /// The string representation of the boot flow.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            BootFlow::Tryboot => "tryboot",
+            BootFlow::UBoot => "u-boot",
+        }
+    }
+}