ser: add patch bootargs for dtb from config.toml

- Add set and get bootargs functions for the dtb that already
  loaded into psram  with serde-device-tree crate.
- Adjust firmware and dtb loading order for patching dtb.
- Test on m1s dock board, which works well.

Refs: rustsbi/serde-device-tree#13
Signed-off-by: DongQing <[email protected]>

Author: Placebo27

Cargo.toml

@@ -22,6 +22,7 @@ riscv = "0.12.1"
 embedded-sdmmc = "0.8.1"
 picotoml = { git = "https://github.com/rustsbi/poplar", branch = "refactor/riscv", default-features = false }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde-device-tree = { git = "https://github.com/rustsbi/serde-device-tree", default-features = false, features = ["ser"]}
 
 [[bin]]
 name = "bouffaloader"

src/error.rs

@@ -1,4 +1,4 @@
-/// Errors that can occur during the loading process.
+/// Errors that can occur during the loading process and device tree parsing.
 #[derive(Debug)]
 pub enum Error<BE>
 where
@@ -8,6 +8,10 @@ where
     BlockDevice(embedded_sdmmc::Error<BE>),
     /// The file length is too long.
     FileLength(u32),
+    /// The file is not a valid DTB.
+    InvalidDTB,
+    /// The device tree magic number is invalid.
+    InvalideMagic(u32),
 }
 
 impl<BE> From<embedded_sdmmc::Error<BE>> for Error<BE>

src/lib.rs

@@ -3,6 +3,7 @@
 mod config;
 pub mod error;
 pub mod sdcard;
+pub mod ser;
 pub mod utils;
 
 pub use error::Error;

src/main.rs

@@ -6,6 +6,7 @@ use bouffalo_rt::{Clocks, Peripherals, entry};
 use bouffaloader::{Device, DynamicInfo};
 use bouffaloader::{
     sdcard,
+    ser::{get_bootargs, set_bootargs},
     utils::{format_hex, parse_hex, read_memory, write_memory},
 };
 use core::fmt::Write as _;
@@ -222,14 +223,18 @@ fn run_cli<
                     },
                     Base::Bootargs { command } => match command {
                         Some(BootargsCommand::Get) => {
-                            writeln!(d.tx, "Bootargs: {:?}", b).ok();
+                            writeln!(d.tx, "Bootargs: {:?}", get_bootargs()).ok();
                         }
                         Some(BootargsCommand::Set { bootarg }) => match bootarg {
                             Some(bootarg) => {
                                 b.clear();
-                                match b.push_str(bootarg) {
+                                let _ = b.push_str(bootarg);
+                                match set_bootargs(&b) {
                                     Ok(_) => writeln!(d.tx, "Bootargs set to: {:?}", b).ok(),
-                                    Err(_) => writeln!(d.tx, "Cannot set bootargs for it's too long for current environment: {:?}", b).ok()
+                                    Err(_) => {
+                                        writeln!(d.tx, "Failed to set bootargs on value `{:?}`.", b)
+                                            .ok()
+                                    }
                                 };
                             }
                             None => {

src/sdcard.rs

@@ -1,4 +1,4 @@
-use super::{Config, Device, Error, config::*};
+use super::{Config, Device, Error, config::*, ser::set_bootargs};
 use embedded_hal::digital::OutputPin;
 use embedded_io::{Read, Write};
 use embedded_sdmmc::{
@@ -80,29 +80,26 @@ pub fn load_from_sdcard<
         return Err(());
     };
 
-    // Load firmware.
-    let firmware_path = config.configs.firmware.as_ref().map(|s| s.as_str()).unwrap_or_else(|| {
-        writeln!(d.tx, "warning: /config.toml: cannot find firmware path on key `configs.firmware`, using default configuration (/zImage).").ok();
-        "ZIMAGE"
-    });
-    let (file_dir, file_name) = locate_file_by_path(&mut d.tx, "firmware", firmware_path);
-    let Ok(firmware) = open_file_by_path(&mut volume_mgr, root_dir, file_dir, file_name) else {
+    // Load device tree blob.
+    let Some(opaque) = config.configs.opaque else {
+        writeln!(d.tx, "warning: /config.toml: cannot find opaque file path on key `configs.opaque`, using default configuration (zeroing `a1` for non-existing opaque file).").ok();
+        volume_mgr.close_dir(root_dir).unwrap();
+        return Ok(0x0);
+    };
+    let dtb_path = opaque.as_str();
+    let (file_dir, file_name) = locate_file_by_path(&mut d.tx, "dtb", dtb_path);
+    let Ok(dtb) = open_file_by_path(&mut volume_mgr, root_dir, file_dir, file_name) else {
         writeln!(
             d.tx,
-            "error: /config.toml: file not found for firmware path {}.",
-            firmware_path
+            "error: /config.toml: file not found for dtb path {}.",
+            dtb_path
         )
         .ok();
         return Err(());
     };
-    writeln!(
-        d.tx,
-        "info: /config.toml: firmware located on {}.",
-        firmware_path
-    )
-    .ok();
-    let result =
-        load_file_into_memory(&mut volume_mgr, firmware, FIRMWARE_ADDRESS, FIRMWARE_LENGTH);
+    writeln!(d.tx, "info: /config.toml: dtb located on {}.", dtb_path).ok();
+    // Load `bl808.dtb`.
+    let result = load_file_into_memory(&mut volume_mgr, dtb, OPAQUE_ADDRESS, OPAQUE_LENGTH);
     match result {
         Ok(bytes) => {
             writeln!(
@@ -113,7 +110,7 @@ pub fn load_from_sdcard<
             .ok();
         }
         Err(Error::FileLength(size)) => {
-            writeln!(d.tx, "error: /config.toml: file size for firmware {} is {} bytes, but maximum supported firmware size on the current platform (BL808) is 32,704 KiB.", firmware_path, size).ok();
+            writeln!(d.tx, "error: /config.toml: file size for dtb {} is {} bytes, but maximum supported dtb size on the current platform (BL808) is 64 KiB.", dtb_path, size).ok();
             return Err(());
         }
         Err(Error::BlockDevice(e)) => {
@@ -125,41 +122,64 @@ pub fn load_from_sdcard<
             .ok();
             return Err(());
         }
+        Err(_) => {}
+    }
+    // Patch bootargs to dtb.
+    if let Some(bootargs) = config.configs.bootargs {
+        writeln!(d.tx, "debug: /config.toml: bootargs load start.").ok();
+        let result = set_bootargs(&bootargs);
+        writeln!(
+            d.tx,
+            "debug: /config.toml: bootargs `{}` load from dtb.",
+            bootargs
+        )
+        .ok();
+        match result {
+            Ok(()) => {
+                writeln!(d.tx, "info: /config.toml: bootargs set to `{}`.", bootargs).ok();
+            }
+            Err(Error::InvalideMagic(_magic)) => {
+                writeln!(d.tx, "warning: /config.toml: bootargs is unused, as `config.opaque` does not include an opaque information file in DTB format.
+        note: /config.toml: `config.bootargs` is set to `console=ttyS0,115200n8 root=/dev/mmcblk0p2 rw rootwait quiet` in the configuration.").ok();
+            }
+            Err(_) => {
+                writeln!(
+                    d.tx,
+                    "error: /config.toml: failed to set bootargs on value `{}`.",
+                    bootargs
+                )
+                .ok();
+            }
+        }
+    } else {
+        writeln!(d.tx, "warning: /config.toml: cannot find bootargs on key `configs.bootargs`, using default bootargs in DTB.").ok();
     }
 
     let root_dir = volume_mgr.open_root_dir(volume0).map_err(|_| ())?;
 
-    // Load device tree blob.
-    let Some(opaque) = config.configs.opaque else {
-        writeln!(d.tx, "warning: /config.toml: cannot find opaque file path on key `configs.opaque`, using default configuration (zeroing `a1` for non-existing opaque file).").ok();
-        volume_mgr.close_dir(root_dir).unwrap();
-        return Ok(0x0);
-    };
-    let dtb_path = opaque.as_str();
-    let (file_dir, file_name) = locate_file_by_path(&mut d.tx, "dtb", dtb_path);
-    let Ok(dtb) = open_file_by_path(&mut volume_mgr, root_dir, file_dir, file_name) else {
+    // Load firmware.
+    let firmware_path = config.configs.firmware.as_ref().map(|s| s.as_str()).unwrap_or_else(|| {
+        writeln!(d.tx, "warning: /config.toml: cannot find firmware path on key `configs.firmware`, using default configuration (/zImage).").ok();
+        "ZIMAGE"
+    });
+    let (file_dir, file_name) = locate_file_by_path(&mut d.tx, "firmware", firmware_path);
+    let Ok(firmware) = open_file_by_path(&mut volume_mgr, root_dir, file_dir, file_name) else {
         writeln!(
             d.tx,
-            "error: /config.toml: file not found for dtb path {}.",
-            dtb_path
+            "error: /config.toml: file not found for firmware path {}.",
+            firmware_path
         )
         .ok();
         return Err(());
     };
-    writeln!(d.tx, "info: /config.toml: dtb located on {}.", dtb_path).ok();
-    // TODO: apply bootargs to dtb.
-    if is_dtb_format(&mut volume_mgr, dtb) {
-        if let Some(bootargs) = config.configs.bootargs {
-            writeln!(d.tx, "info: /config.toml: bootargs set to `{}`.", bootargs).ok();
-        } else {
-            writeln!(d.tx, "warning: /config.toml: cannot find bootargs on key `configs.bootargs`, using default bootargs in DTB.").ok();
-        }
-    } else {
-        writeln!(d.tx, "warning: /config.toml: bootargs is unused, as `config.opaque` does not include an opaque information file in DTB format.
-        note: /config.toml: `config.bootargs` is set to `console=ttyS0,115200n8 root=/dev/mmcblk0p2 rw rootwait quiet` in the configuration.").ok();
-    }
-    // Load `bl808.dtb`.
-    let result = load_file_into_memory(&mut volume_mgr, dtb, OPAQUE_ADDRESS, OPAQUE_LENGTH);
+    writeln!(
+        d.tx,
+        "info: /config.toml: firmware located on {}.",
+        firmware_path
+    )
+    .ok();
+    let result =
+        load_file_into_memory(&mut volume_mgr, firmware, FIRMWARE_ADDRESS, FIRMWARE_LENGTH);
     match result {
         Ok(bytes) => {
             writeln!(
@@ -170,7 +190,7 @@ pub fn load_from_sdcard<
             .ok();
         }
         Err(Error::FileLength(size)) => {
-            writeln!(d.tx, "error: /config.toml: file size for dtb {} is {} bytes, but maximum supported dtb size on the current platform (BL808) is 64 KiB.", dtb_path, size).ok();
+            writeln!(d.tx, "error: /config.toml: file size for firmware {} is {} bytes, but maximum supported firmware size on the current platform (BL808) is 32,704 KiB.", firmware_path, size).ok();
             return Err(());
         }
         Err(Error::BlockDevice(e)) => {
@@ -182,7 +202,9 @@ pub fn load_from_sdcard<
             .ok();
             return Err(());
         }
+        Err(_) => {}
     }
+
     Ok(OPAQUE_ADDRESS)
 }
 

src/ser.rs

@@ -0,0 +1,59 @@
+use super::config::*;
+use super::error::Error;
+use heapless::String;
+use serde_device_tree::error::{Error as DtbError, ErrorType};
+use serde_device_tree::ser::patch::Patch;
+use serde_device_tree::ser::to_dtb;
+use serde_device_tree::{Dtb, DtbPtr, buildin::Node, buildin::StrSeq, from_raw_mut};
+
+/// Set the bootargs of the dtb.
+pub fn set_bootargs(new_bootargs: &String<128>) -> Result<(), Error<()>> {
+    match DtbPtr::from_raw(OPAQUE_ADDRESS as *mut u8) {
+        Ok(ptr) => {
+            // Get the aligned size of the dtb.
+            let size = ptr.align();
+            let dtb = Dtb::from(ptr).share();
+            let root: Node = from_raw_mut(&dtb).map_err(|_| Error::InvalidDTB)?;
+            let patch = Patch::new("/chosen/bootargs", new_bootargs);
+            let patches = [patch];
+            let mut temp_buffer =
+                unsafe { core::slice::from_raw_parts_mut(FIRMWARE_ADDRESS as *mut u8, size * 2) };
+            to_dtb(&root, &patches, &mut temp_buffer).map_err(|_| Error::InvalidDTB)?;
+            let target =
+                unsafe { core::slice::from_raw_parts_mut(OPAQUE_ADDRESS as *mut u8, size) };
+            target.copy_from_slice(&temp_buffer[..size]);
+
+            Ok(())
+        }
+        Err(DtbError::Typed {
+            error_type: ErrorType::InvalidMagic { wrong_magic },
+            ..
+        }) => Err(Error::InvalideMagic(wrong_magic)),
+        Err(_) => Err(Error::InvalidDTB),
+    }
+}
+
+/// Get the bootargs of the dtb.
+pub fn get_bootargs() -> Result<&'static str, ()> {
+    match DtbPtr::from_raw(OPAQUE_ADDRESS as *mut u8) {
+        Ok(ptr) => {
+            let dtb = Dtb::from(ptr).share();
+            let root: Node = from_raw_mut(&dtb).map_err(|_| ())?;
+            let result = root
+                .chosen()
+                .ok_or(())?
+                .get_prop("bootargs")
+                .ok_or(())?
+                .deserialize::<StrSeq>()
+                .iter()
+                .next()
+                .ok_or(())?;
+            if let Some(pos) = result.find(':') {
+                return Ok(result.split_at(pos).0);
+            } else {
+                return Err(());
+            }
+        }
+        Err(_) => Err(()),
+    }
+}