Merge pull request #23 from woshiluo/nemu

feat: add support for payload image

Cargo.lock

@@ -14,6 +14,12 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -170,6 +176,7 @@ dependencies = [
  "sifive-test-device",
  "spin",
  "uart16550",
+ "uart_xilinx",
 ]
 
 [[package]]
@@ -286,8 +293,32 @@ version = "0.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "939f6f9ccad815fe3efca8fd06f2ec1620c0387fb1bca2b231b61ce710bffb9b"
 
+[[package]]
+name = "uart_xilinx"
+version = "0.2.0"
+source = "git+https://github.com/duskmoon314/uart-rs/#12be91421ad140f2a4bf4179578fd7a8fbc7ff5c"
+dependencies = [
+ "bitflags",
+ "volatile-register",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "vcell"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002"
+
+[[package]]
+name = "volatile-register"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de437e2a6208b014ab52972a27e59b33fa2920d3e00fe05026167a1c509d19cc"
+dependencies = [
+ "vcell",
+]

Makefile.toml

@@ -5,6 +5,17 @@ default_to_workspace = false
 command = "cargo"
 args = ["clean"]
 
+[tasks.prototyper-nemu-build]
+command = "cargo"
+args = ["build", "-prustsbi-prototyper", "--release", "--features=nemu,payload"]
+
+[tasks.prototyper-nemu]
+command = "rust-objcopy"
+args = ["--binary-architecture=riscv64", "target/riscv64imac-unknown-none-elf/release/rustsbi-prototyper",
+        "--output-target=binary", "target/riscv64imac-unknown-none-elf/release/rustsbi-prototyper.bin"
+]
+dependencies = ["prototyper-nemu-build"]
+
 [tasks.prototyper-build]
 command = "cargo"
 args = ["build", "-prustsbi-prototyper", "--release"]

prototyper/Cargo.toml

@@ -22,6 +22,7 @@ spin = "0.9.8"
 uart16550 = "0.0.1"
 riscv-decode = "0.2.1"
 fast-trap = { version = "0.0.1", features = ["riscv-m"] }
+uart_xilinx = { git = "https://github.com/duskmoon314/uart-rs/" }
 
 
 [[bin]]
@@ -29,3 +30,6 @@ name = "rustsbi-prototyper"
 test = false
 bench = false
 
+[features]
+nemu = []
+payload = []

prototyper/build.rs

@@ -6,11 +6,54 @@ fn main() {
 
     std::fs::write(ld, LINKER_SCRIPT).unwrap();
 
-    println!("cargo:rerun-if-env-changed=RUST_LOG");
+    println!("cargo:rerun-if-env-changed=RUST_LOG,PROTOTYPER_FDT,PROTOTYPER_IMAGE");
     println!("cargo:rustc-link-arg=-T{}", ld.display());
     println!("cargo:rustc-link-search={}", out.display());
 }
 
+#[cfg(feature = "payload")]
+const LINKER_SCRIPT: &[u8] = b"OUTPUT_ARCH(riscv)
+ENTRY(_start) 
+SECTIONS {
+    . = 0x80000000;
+    .text : ALIGN(8) { 
+        *(.text.entry)
+        *(.text .text.*)
+    }
+    .rodata : ALIGN(8) { 
+        srodata = .;
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+        . = ALIGN(8);  
+        erodata = .;
+    } 
+    .data : ALIGN(8) { 
+        sdata = .;
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+        . = ALIGN(8); 
+        edata = .;
+    }
+    sidata = LOADADDR(.data);
+    .bss (NOLOAD) : ALIGN(8) {  
+        *(.bss.uninit)
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+        ebss = .;
+    } 
+    /DISCARD/ : {
+        *(.eh_frame)
+    }
+    .text 0x80100000 : ALIGN(8) {
+        *(.fw_fdt)
+    }
+    .text 0x80200000 : ALIGN(8) {
+        *(.payload)
+    }
+}";
+
+#[cfg(not(feature = "payload"))]
 const LINKER_SCRIPT: &[u8] = b"OUTPUT_ARCH(riscv)
 ENTRY(_start) 
 SECTIONS {

prototyper/src/board.rs

@@ -1,13 +1,13 @@
 use aclint::SifiveClint;
 use core::mem::MaybeUninit;
-use core::ptr::null;
 use core::{
-    ptr::null_mut,
+    ptr::{null, null_mut},
     sync::atomic::{AtomicPtr, Ordering::Release},
 };
 use sifive_test_device::SifiveTestDevice;
 use spin::Mutex;
 use uart16550::Uart16550;
+use uart_xilinx::uart_lite::uart::MmioUartAxiLite;
 
 use crate::sbi::console::ConsoleDevice;
 use crate::sbi::ipi::IpiDevice;
@@ -22,6 +22,7 @@ pub(crate) static mut SBI_IMPL: MaybeUninit<
 #[doc(hidden)]
 pub enum MachineConsole {
     Uart16550(*const Uart16550<u8>),
+    UartAxiLite(MmioUartAxiLite),
 }
 
 unsafe impl Send for MachineConsole {}
@@ -31,20 +32,32 @@ impl ConsoleDevice for MachineConsole {
     fn read(&self, buf: &mut [u8]) -> usize {
         match self {
             Self::Uart16550(uart16550) => unsafe { (**uart16550).read(buf) },
+            Self::UartAxiLite(axilite) => axilite.read(buf),
         }
     }
 
     fn write(&self, buf: &[u8]) -> usize {
         match self {
             MachineConsole::Uart16550(uart16550) => unsafe { (**uart16550).write(buf) },
+            Self::UartAxiLite(axilite) => axilite.write(buf),
         }
     }
 }
 
+// TODO: select driver follow fdt
+
 #[doc(hidden)]
+#[cfg(feature = "nemu")]
+pub(crate) static UART: Mutex<MachineConsole> =
+    Mutex::new(MachineConsole::UartAxiLite(MmioUartAxiLite::new(0)));
+#[cfg(not(feature = "nemu"))]
 pub(crate) static UART: Mutex<MachineConsole> = Mutex::new(MachineConsole::Uart16550(null()));
 pub(crate) fn console_dev_init(base: usize) {
-    *UART.lock() = MachineConsole::Uart16550(base as _);
+    let new_console = match *UART.lock() {
+        MachineConsole::Uart16550(_) => MachineConsole::Uart16550(base as _),
+        MachineConsole::UartAxiLite(_) => MachineConsole::UartAxiLite(MmioUartAxiLite::new(base)),
+    };
+    *UART.lock() = new_console;
 }
 
 /// Ipi Device: Sifive Clint

prototyper/src/fail.rs

@@ -1,11 +1,12 @@
-use riscv::register::mstatus;
 use serde_device_tree::Dtb;
 
+use crate::dt::{self, ParseDeviceTreeError, Tree};
 use crate::sbi::reset;
-use crate::{
-    dt::{self, ParseDeviceTreeError, Tree},
-    dynamic,
-};
+
+#[cfg(not(feature = "payload"))]
+use crate::platform::dynamic;
+#[cfg(not(feature = "payload"))]
+use riscv::register::mstatus;
 
 #[cold]
 pub fn device_tree_format(err: dt::ParseDeviceTreeError) -> Dtb {
@@ -22,6 +23,7 @@ pub fn device_tree_deserialize<'a>(err: serde_device_tree::error::Error) -> Tree
 }
 
 #[cold]
+#[cfg(not(feature = "payload"))]
 pub fn invalid_dynamic_data(err: dynamic::DynamicError) -> (mstatus::MPP, usize) {
     error!("Invalid data in dynamic information:");
     if err.invalid_mpp {
@@ -44,6 +46,7 @@ pub fn invalid_dynamic_data(err: dynamic::DynamicError) -> (mstatus::MPP, usize)
 }
 
 #[cold]
+#[cfg(not(feature = "payload"))]
 pub fn no_dynamic_info_available(err: dynamic::DynamicReadError) -> dynamic::DynamicInfo {
     if let Some(bad_paddr) = err.bad_paddr {
         error!(
@@ -70,3 +73,16 @@ pub fn no_dynamic_info_available(err: dynamic::DynamicReadError) -> dynamic::Dyn
     }
     reset::fail()
 }
+
+#[cold]
+#[cfg(not(feature = "payload"))]
+pub fn use_lottery(_err: dynamic::DynamicReadError) -> dynamic::DynamicInfo {
+    dynamic::DynamicInfo {
+        magic: 0,
+        version: 0,
+        next_addr: 0,
+        next_mode: 0,
+        options: 0,
+        boot_hart: usize::MAX,
+    }
+}

prototyper/src/main.rs

@@ -10,8 +10,8 @@ mod macros;
 
 mod board;
 mod dt;
-mod dynamic;
 mod fail;
+mod platform;
 mod riscv_spec;
 mod sbi;
 
@@ -19,6 +19,8 @@ use core::sync::atomic::{AtomicBool, Ordering};
 use core::{arch::asm, mem::MaybeUninit};
 
 use crate::board::{SBI_IMPL, SIFIVECLINT, SIFIVETEST, UART};
+#[cfg(not(feature = "payload"))]
+use crate::platform::dynamic;
 use crate::riscv_spec::{current_hartid, menvcfg};
 use crate::sbi::console::SbiConsole;
 use crate::sbi::hart_context::NextStage;
@@ -34,37 +36,34 @@ use crate::sbi::SBI;
 #[no_mangle]
 extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
     // parse dynamic information
-    let info = dynamic::read_paddr(nonstandard_a2).unwrap_or_else(fail::no_dynamic_info_available);
-    static GENESIS: AtomicBool = AtomicBool::new(true);
     static SBI_READY: AtomicBool = AtomicBool::new(false);
 
-    let is_boot_hart = if info.boot_hart == usize::MAX {
-        GENESIS.swap(false, Ordering::AcqRel)
-    } else {
-        current_hartid() == info.boot_hart
-    };
-
-    if is_boot_hart {
-        let (mpp, next_addr) =
-            dynamic::mpp_next_addr(&info).unwrap_or_else(fail::invalid_dynamic_data);
+    let boot_hart_info = platform::get_boot_hart(opaque, nonstandard_a2);
 
-        // parse the device tree
+    if boot_hart_info.is_boot_hart {
+        let fdt_addr = boot_hart_info.fdt_address;
 
         // 1. Init FDT
-        let dtb = dt::parse_device_tree(opaque).unwrap_or_else(fail::device_tree_format);
+        // parse the device tree
+        let dtb = dt::parse_device_tree(fdt_addr).unwrap_or_else(fail::device_tree_format);
         let dtb = dtb.share();
         let tree =
             serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
 
         // 2. Init device
         // TODO: The device base address should be find in a better way
-        let reset_device = tree.soc.test.unwrap().iter().next().unwrap();
         let console_base = tree.soc.serial.unwrap().iter().next().unwrap();
         let clint_device = tree.soc.clint.unwrap().iter().next().unwrap();
-        let reset_base_address = reset_device.at();
         let console_base_address = console_base.at();
         let ipi_base_address = clint_device.at();
-        board::reset_dev_init(usize::from_str_radix(reset_base_address, 16).unwrap());
+
+        // Set reset device if found it
+        if let Some(test) = tree.soc.test {
+            let reset_device = test.iter().next().unwrap();
+            let reset_base_address = reset_device.at();
+            board::reset_dev_init(usize::from_str_radix(reset_base_address, 16).unwrap());
+        }
+
         board::console_dev_init(usize::from_str_radix(console_base_address, 16).unwrap());
         board::ipi_dev_init(usize::from_str_radix(ipi_base_address, 16).unwrap());
         // Assume sstc is enabled only if all hart has sstc ext
@@ -79,9 +78,11 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
                     Some(value) => value,
                     None => return false,
                 };
-                isa.iter().find(|&x| x == "sstc").is_some()
+                isa.iter().any(|x| x == "sstc")
             })
             .all(|x| x);
+        #[cfg(feature = "nemu")]
+        let sstc_support = true;
         // 3. Init SBI
         unsafe {
             SBI_IMPL = MaybeUninit::new(SBI {
@@ -105,7 +106,6 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         info!("Support sstc: {sstc_support}");
         info!("Clint device: {}", ipi_base_address);
         info!("Console deivce: {}", console_base_address);
-        info!("Reset device: {}", reset_base_address);
         info!(
             "Chosen stdout item: {}",
             tree.chosen
@@ -127,11 +127,13 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         // 设置陷入栈
         trap_stack::prepare_for_trap();
 
+        let boot_info = platform::get_boot_info(nonstandard_a2);
+        let (mpp, next_addr) = (boot_info.mpp, boot_info.next_address);
         // 设置内核入口
         local_remote_hsm().start(NextStage {
             start_addr: next_addr,
             next_mode: mpp,
-            opaque,
+            opaque: fdt_addr,
         });
 
         info!(
@@ -154,7 +156,9 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         trap_stack::prepare_for_trap();
 
         // waiting for sbi ready
-        while !SBI_READY.load(Ordering::Relaxed) {}
+        while !SBI_READY.load(Ordering::Relaxed) {
+            core::hint::spin_loop()
+        }
     }
 
     ipi::clear_all();
@@ -186,29 +190,34 @@ unsafe extern "C" fn start() -> ! {
         // 2. Initialize programming langauge runtime
         // only clear bss if hartid matches preferred boot hart id
         "   csrr    t0, mhartid",
-        "   ld      t1, 0(a2)",
-        "   li      t2, {magic}",
-        "   bne     t1, t2, 3f",
-        "   ld      t2, 40(a2)",
-        "   bne     t0, t2, 2f",
-        "   j       4f",
-        "3:",
-        "   j       3b", // TODO multi hart preempt for runtime init
-        "4:",
-        // 3. clear bss segment
+        "   bne     t0, zero, 4f",
+        "1:",
+        // 3. Hart 0 clear bss segment
         "   la      t0, sbss
             la      t1, ebss
-        1:  bgeu    t0, t1, 2f
+         2: bgeu    t0, t1, 3f
             sd      zero, 0(t0)
             addi    t0, t0, 8
-            j       1b",
-        "2:",
+            j       2b",
+        "3: ", // Hart 0 set bss ready signal
+        "   la      t0, 6f
+            li      t1, 1
+            amoadd.w t0, t1, 0(t0)
+            j       5f",
+        "4:", // Other harts are waiting for bss ready signal
+        "   li      t1, 1
+            la      t0, 6f
+            lw      t0, 0(t0)
+            bne     t0, t1, 4b", 
+        "5:",
          // 4. Prepare stack for each hart
         "   call    {locate_stack}",
         "   call    {main}",
         "   csrw    mscratch, sp",
         "   j       {hart_boot}",
-        magic = const dynamic::MAGIC,
+        "  .balign  4",
+        "6:",  // bss ready signal
+        "  .word    0",
         locate_stack = sym trap_stack::locate,
         main         = sym rust_main,
         hart_boot    = sym trap::msoft,

prototyper/src/dynamic.rs → prototyper/src/platform/dynamic.rs

@@ -1,9 +1,38 @@
 //! Frequently used first boot stage dynamic information on RISC-V.
 
 use core::ops::Range;
+use core::sync::atomic::{AtomicBool, Ordering};
+
+use super::{BootHart, BootInfo};
+use crate::fail;
+use crate::riscv_spec::current_hartid;
 
 use riscv::register::mstatus;
 
+pub fn get_boot_hart(opaque: usize, nonstandard_a2: usize) -> BootHart {
+    static GENESIS: AtomicBool = AtomicBool::new(true);
+    let info = read_paddr(nonstandard_a2).unwrap_or_else(fail::use_lottery);
+    let is_boot_hart = if info.boot_hart == usize::MAX {
+        GENESIS.swap(false, Ordering::AcqRel)
+    } else {
+        current_hartid() == info.boot_hart
+    };
+    BootHart {
+        fdt_address: opaque,
+        is_boot_hart,
+    }
+}
+
+pub fn get_boot_info(nonstandard_a2: usize) -> BootInfo {
+    static GENESIS: AtomicBool = AtomicBool::new(true);
+    let dynamic_info = read_paddr(nonstandard_a2).unwrap_or_else(fail::no_dynamic_info_available);
+    let (mpp, next_addr) = mpp_next_addr(&dynamic_info).unwrap_or_else(fail::invalid_dynamic_data);
+    BootInfo {
+        next_address: next_addr,
+        mpp,
+    }
+}
+
 /// M-mode firmware dynamic information.
 #[derive(Clone, Copy)]
 #[repr(C)]

prototyper/src/platform/mod.rs

@@ -0,0 +1,21 @@
+#[cfg(not(feature = "payload"))]
+pub mod dynamic;
+#[cfg(feature = "payload")]
+pub mod payload;
+
+use riscv::register::mstatus;
+
+pub struct BootInfo {
+    pub next_address: usize,
+    pub mpp: mstatus::MPP,
+}
+
+pub struct BootHart {
+    pub fdt_address: usize,
+    pub is_boot_hart: bool,
+}
+
+#[cfg(not(feature = "payload"))]
+pub use dynamic::{get_boot_hart, get_boot_info};
+#[cfg(feature = "payload")]
+pub use payload::{get_boot_hart, get_boot_info};

prototyper/src/platform/payload.rs

@@ -0,0 +1,46 @@
+use super::{BootHart, BootInfo};
+use core::arch::asm;
+
+use riscv::register::mstatus;
+
+pub fn get_boot_hart(_opaque: usize, _nonstandard_a2: usize) -> BootHart {
+    BootHart {
+        fdt_address: get_fdt_address(),
+        is_boot_hart: true,
+    }
+}
+
+pub fn get_boot_info(_nonstandard_a2: usize) -> BootInfo {
+    BootInfo {
+        next_address: get_image_address(),
+        mpp: mstatus::MPP::Supervisor,
+    }
+}
+
+#[naked]
+#[link_section = ".fw_fdt"]
+pub unsafe extern "C" fn raw_fdt() {
+    asm!(
+        concat!(".incbin \"", env!("PROTOTYPER_FDT"), "\""),
+        options(noreturn)
+    );
+}
+
+#[naked]
+#[link_section = ".payload"]
+pub unsafe extern "C" fn payload_image() {
+    asm!(
+        concat!(".incbin \"", env!("PROTOTYPER_IMAGE"), "\""),
+        options(noreturn)
+    );
+}
+
+#[inline]
+fn get_fdt_address() -> usize {
+    raw_fdt as usize
+}
+
+#[inline]
+fn get_image_address() -> usize {
+    payload_image as usize
+}

prototyper/src/sbi/fifo.rs

@@ -57,7 +57,7 @@ impl<T: Copy + Clone> Fifo<T> {
         } as usize;
 
         self.avil -= 1;
-        let result = unsafe { self.data[head].assume_init_ref() }.clone();
+        let result = *unsafe { self.data[head].assume_init_ref() };
         unsafe { self.data[head].assume_init_drop() }
         Ok(result)
     }